diff --git a/actor/v7action/cloud_controller_client.go b/actor/v7action/cloud_controller_client.go index eeced08437..aa59acd614 100644 --- a/actor/v7action/cloud_controller_client.go +++ b/actor/v7action/cloud_controller_client.go @@ -14,6 +14,11 @@ import ( // CloudControllerClient is the interface to the cloud controller V3 API. type CloudControllerClient interface { + GetServiceAccount(guid string) (resources.ServiceAccount, ccv3.Warnings, error) + DeleteServiceAccount(guid string) (ccv3.JobURL, ccv3.Warnings, error) + UpdateServiceAccountEnabled(guid string, enabled bool) (ccv3.JobURL, ccv3.Warnings, error) + UpdateApplicationServiceAccount(appGUID string, relationship resources.Relationship) (ccv3.JobURL, ccv3.Warnings, error) + GetServiceAccounts(query ...ccv3.Query) ([]resources.ServiceAccount, ccv3.Warnings, error) ApplyOrganizationQuota(quotaGUID string, orgGUID string) (resources.RelationshipList, ccv3.Warnings, error) ApplySpaceQuota(quotaGUID string, spaceGUID string) (resources.RelationshipList, ccv3.Warnings, error) CheckRoute(domainGUID string, hostname string, path string, port int) (bool, ccv3.Warnings, error) @@ -40,6 +45,7 @@ type CloudControllerClient interface { CreateServiceCredentialBinding(binding resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error) CreateServiceInstance(serviceInstance resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) CreateSecurityGroup(securityGroup resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) + CreateServiceAccount(account resources.ServiceAccount) (resources.ServiceAccount, ccv3.Warnings, error) CreateSpace(space resources.Space) (resources.Space, ccv3.Warnings, error) CreateSpaceQuota(spaceQuota resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) CreateUser(userGUID string) (resources.User, ccv3.Warnings, error) diff --git a/actor/v7action/service_account.go b/actor/v7action/service_account.go new file mode 100644 index 0000000000..2b4e31506c --- /dev/null +++ b/actor/v7action/service_account.go @@ -0,0 +1,93 @@ +package v7action + +import ( + "fmt" + + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/resources" +) + +func (actor Actor) GetServiceAccountByNameAndSpace(name, spaceGUID string) (resources.ServiceAccount, Warnings, error) { + accounts, warnings, err := actor.CloudControllerClient.GetServiceAccounts( + ccv3.Query{Key: ccv3.NameFilter, Values: []string{name}}, + ccv3.Query{Key: ccv3.SpaceGUIDFilter, Values: []string{spaceGUID}}, + ) + allWarnings := Warnings(warnings) + if err != nil { + return resources.ServiceAccount{}, allWarnings, err + } + if len(accounts) == 0 { + return resources.ServiceAccount{}, allWarnings, fmt.Errorf("Service account '%s' not found in the targeted space.", name) + } + if len(accounts) != 1 { + return resources.ServiceAccount{}, allWarnings, fmt.Errorf("Service account '%s' resolved to multiple accounts.", name) + } + account, warnings, err := actor.CloudControllerClient.GetServiceAccount(accounts[0].GUID) + return account, append(allWarnings, warnings...), err +} + +func (actor Actor) DeleteServiceAccountByNameAndSpace(name, spaceGUID string) (Warnings, error) { + account, warnings, err := actor.GetServiceAccountByNameAndSpace(name, spaceGUID) + if err != nil { + return warnings, err + } + job, mutationWarnings, err := actor.CloudControllerClient.DeleteServiceAccount(account.GUID) + return actor.completeServiceAccountOperation(job, append(warnings, mutationWarnings...), err) +} + +func (actor Actor) SetServiceAccountEnabledByNameAndSpace(name, spaceGUID string, enabled bool) (Warnings, error) { + account, warnings, err := actor.GetServiceAccountByNameAndSpace(name, spaceGUID) + if err != nil { + return warnings, err + } + job, mutationWarnings, err := actor.CloudControllerClient.UpdateServiceAccountEnabled(account.GUID, enabled) + return actor.completeServiceAccountOperation(job, append(warnings, mutationWarnings...), err) +} + +func (actor Actor) BindServiceAccountByNameAndSpace(appName, accountName, spaceGUID string) (Warnings, error) { + app, warnings, err := actor.GetApplicationByNameAndSpace(appName, spaceGUID) + if err != nil { + return warnings, err + } + account, accountWarnings, err := actor.GetServiceAccountByNameAndSpace(accountName, spaceGUID) + warnings = append(warnings, accountWarnings...) + if err != nil { + return warnings, err + } + job, mutationWarnings, err := actor.CloudControllerClient.UpdateApplicationServiceAccount(app.GUID, resources.Relationship{GUID: account.GUID}) + return actor.completeServiceAccountOperation(job, append(warnings, mutationWarnings...), err) +} + +func (actor Actor) UnbindServiceAccountByAppNameAndSpace(appName, spaceGUID string) (Warnings, error) { + app, warnings, err := actor.GetApplicationByNameAndSpace(appName, spaceGUID) + if err != nil { + return warnings, err + } + job, mutationWarnings, err := actor.CloudControllerClient.UpdateApplicationServiceAccount(app.GUID, resources.Relationship{}) + return actor.completeServiceAccountOperation(job, append(warnings, mutationWarnings...), err) +} + +func (actor Actor) completeServiceAccountOperation(job ccv3.JobURL, warnings Warnings, err error) (Warnings, error) { + if err != nil || job == "" { + return warnings, err + } + pollWarnings, err := actor.CloudControllerClient.PollJob(job) + return append(warnings, pollWarnings...), err +} + +func (actor Actor) GetServiceAccountsInSpace(spaceGUID string) ([]resources.ServiceAccount, Warnings, error) { + accounts, warnings, err := actor.CloudControllerClient.GetServiceAccounts(ccv3.Query{ + Key: ccv3.SpaceGUIDFilter, Values: []string{spaceGUID}, + }) + return accounts, Warnings(warnings), err +} + +func (actor Actor) CreateServiceAccountInSpace(name, description, spaceGUID string) (resources.ServiceAccount, Warnings, error) { + account, warnings, err := actor.CloudControllerClient.CreateServiceAccount(resources.ServiceAccount{ + Name: name, + Description: description, + Relationships: resources.Relationships{constant.RelationshipTypeSpace: {GUID: spaceGUID}}, + }) + return account, Warnings(warnings), err +} diff --git a/actor/v7action/service_account_lifecycle_test.go b/actor/v7action/service_account_lifecycle_test.go new file mode 100644 index 0000000000..eb2f84d7a5 --- /dev/null +++ b/actor/v7action/service_account_lifecycle_test.go @@ -0,0 +1,122 @@ +package v7action_test + +import ( + "errors" + + . "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/actor/v7action/v7actionfakes" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" +) + +var _ = Describe("Service Account Lifecycle Actions", func() { + var actor *Actor + var client *v7actionfakes.FakeCloudControllerClient + BeforeEach(func() { + client = new(v7actionfakes.FakeCloudControllerClient) + actor = NewActor(client, nil, nil, nil, nil, nil) + client.GetServiceAccountsReturns([]resources.ServiceAccount{{GUID: "account-guid", Name: "workers"}}, ccv3.Warnings{"lookup warning"}, nil) + client.GetServiceAccountReturns(resources.ServiceAccount{GUID: "account-guid", Name: "workers", Status: "ready"}, ccv3.Warnings{"detail warning"}, nil) + client.GetApplicationsReturns([]resources.Application{{GUID: "app-guid", Name: "app"}}, ccv3.Warnings{"app warning"}, nil) + client.DeleteServiceAccountReturns("job-url", ccv3.Warnings{"mutation warning"}, nil) + client.UpdateServiceAccountEnabledReturns("job-url", ccv3.Warnings{"mutation warning"}, nil) + client.UpdateApplicationServiceAccountReturns("job-url", ccv3.Warnings{"mutation warning"}, nil) + client.PollJobReturns(ccv3.Warnings{"poll warning"}, nil) + }) + It("resolves by name AND owning space, then fetches current detail", func() { + account, warnings, err := actor.GetServiceAccountByNameAndSpace("workers", "space-guid") + Expect(err).NotTo(HaveOccurred()) + Expect(account.Status).To(Equal("ready")) + Expect(warnings).To(Equal(Warnings{"lookup warning", "detail warning"})) + Expect(client.GetServiceAccountsArgsForCall(0)).To(Equal([]ccv3.Query{{Key: ccv3.NameFilter, Values: []string{"workers"}}, {Key: ccv3.SpaceGUIDFilter, Values: []string{"space-guid"}}})) + Expect(client.GetServiceAccountArgsForCall(0)).To(Equal("account-guid")) + }) + It("returns a helpful missing-account error without fetching or mutating another space", func() { + client.GetServiceAccountsReturns(nil, ccv3.Warnings{"lookup warning"}, nil) + _, warnings, err := actor.GetServiceAccountByNameAndSpace("workers", "space-guid") + Expect(err).To(MatchError("Service account 'workers' not found in the targeted space.")) + Expect(warnings).To(ConsistOf("lookup warning")) + Expect(client.GetServiceAccountCallCount()).To(BeZero()) + }) + DescribeTable("waits for lifecycle completion and preserves every warning", func(operation string) { + var warnings Warnings + var err error + switch operation { + case "delete": + warnings, err = actor.DeleteServiceAccountByNameAndSpace("workers", "space-guid") + case "enable": + warnings, err = actor.SetServiceAccountEnabledByNameAndSpace("workers", "space-guid", true) + case "disable": + warnings, err = actor.SetServiceAccountEnabledByNameAndSpace("workers", "space-guid", false) + case "bind": + warnings, err = actor.BindServiceAccountByNameAndSpace("app", "workers", "space-guid") + case "unbind": + warnings, err = actor.UnbindServiceAccountByAppNameAndSpace("app", "space-guid") + } + Expect(err).NotTo(HaveOccurred()) + Expect(client.PollJobCallCount()).To(Equal(1)) + Expect(client.PollJobArgsForCall(0)).To(Equal(ccv3.JobURL("job-url"))) + Expect(warnings).To(ContainElements("mutation warning", "poll warning")) + if operation == "bind" || operation == "unbind" { + Expect(client.GetApplicationsArgsForCall(0)).To(ContainElements(ccv3.Query{Key: ccv3.NameFilter, Values: []string{"app"}}, ccv3.Query{Key: ccv3.SpaceGUIDFilter, Values: []string{"space-guid"}})) + guid, relationship := client.UpdateApplicationServiceAccountArgsForCall(0) + Expect(guid).To(Equal("app-guid")) + if operation == "bind" { + Expect(relationship.GUID).To(Equal("account-guid")) + } else { + Expect(relationship.GUID).To(BeEmpty()) + Expect(client.GetServiceAccountsCallCount()).To(BeZero()) + } + } else if operation == "delete" { + Expect(client.DeleteServiceAccountArgsForCall(0)).To(Equal("account-guid")) + } else { + guid, enabled := client.UpdateServiceAccountEnabledArgsForCall(0) + Expect(guid).To(Equal("account-guid")) + Expect(enabled).To(Equal(operation == "enable")) + } + }, Entry("delete", "delete"), Entry("enable", "enable"), Entry("disable", "disable"), Entry("bind", "bind"), Entry("unbind", "unbind")) + + It("does not poll synchronous unbinding", func() { + client.UpdateApplicationServiceAccountReturns("", ccv3.Warnings{"restart warning"}, nil) + warnings, err := actor.UnbindServiceAccountByAppNameAndSpace("app", "space-guid") + Expect(err).NotTo(HaveOccurred()) + Expect(warnings).To(ContainElement("restart warning")) + Expect(client.PollJobCallCount()).To(BeZero()) + }) + It("stops binding when account lookup fails", func() { + client.GetServiceAccountsReturns(nil, ccv3.Warnings{"lookup warning"}, errors.New("lookup denied")) + warnings, err := actor.BindServiceAccountByNameAndSpace("app", "workers", "space-guid") + Expect(err).To(MatchError("lookup denied")) + Expect(warnings).To(ContainElement("lookup warning")) + Expect(client.UpdateApplicationServiceAccountCallCount()).To(BeZero()) + }) + It("stops unbinding when app lookup fails", func() { + client.GetApplicationsReturns(nil, ccv3.Warnings{"app warning"}, errors.New("app denied")) + warnings, err := actor.UnbindServiceAccountByAppNameAndSpace("app", "space-guid") + Expect(err).To(MatchError("app denied")) + Expect(warnings).To(ContainElement("app warning")) + Expect(client.UpdateApplicationServiceAccountCallCount()).To(BeZero()) + }) + It("stops deletion on detail failure", func() { + client.GetServiceAccountReturns(resources.ServiceAccount{}, ccv3.Warnings{"detail warning"}, errors.New("detail denied")) + warnings, err := actor.DeleteServiceAccountByNameAndSpace("workers", "space-guid") + Expect(err).To(MatchError("detail denied")) + Expect(warnings).To(ContainElement("detail warning")) + Expect(client.DeleteServiceAccountCallCount()).To(BeZero()) + }) + It("does not poll a rejected disable operation", func() { + client.UpdateServiceAccountEnabledReturns("", ccv3.Warnings{"mutation warning"}, errors.New("operation in progress")) + warnings, err := actor.SetServiceAccountEnabledByNameAndSpace("workers", "space-guid", false) + Expect(err).To(MatchError("operation in progress")) + Expect(warnings).To(ContainElement("mutation warning")) + Expect(client.PollJobCallCount()).To(BeZero()) + }) + It("reports job failure with poll warnings", func() { + client.PollJobReturns(ccv3.Warnings{"poll warning"}, errors.New("provisioning failed")) + warnings, err := actor.BindServiceAccountByNameAndSpace("app", "workers", "space-guid") + Expect(err).To(MatchError("provisioning failed")) + Expect(warnings).To(ContainElements("app warning", "lookup warning", "detail warning", "mutation warning", "poll warning")) + }) +}) diff --git a/actor/v7action/service_account_test.go b/actor/v7action/service_account_test.go new file mode 100644 index 0000000000..775c8f6ed7 --- /dev/null +++ b/actor/v7action/service_account_test.go @@ -0,0 +1,58 @@ +package v7action_test + +import ( + "errors" + + . "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/actor/v7action/v7actionfakes" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" +) + +var _ = Describe("Service Account Actions", func() { + var actor *Actor + var client *v7actionfakes.FakeCloudControllerClient + BeforeEach(func() { + client = new(v7actionfakes.FakeCloudControllerClient) + actor = NewActor(client, nil, nil, nil, nil, nil) + }) + It("lists only the specified owning space and preserves results and warnings", func() { + accounts := []resources.ServiceAccount{{Name: "shared-worker", Status: "ready"}} + client.GetServiceAccountsReturns(accounts, ccv3.Warnings{"warning"}, nil) + result, warnings, err := actor.GetServiceAccountsInSpace("space-guid") + Expect(err).NotTo(HaveOccurred()) + Expect(result).To(Equal(accounts)) + Expect(warnings).To(ConsistOf("warning")) + Expect(client.GetServiceAccountsCallCount()).To(Equal(1)) + Expect(client.GetServiceAccountsArgsForCall(0)).To(Equal([]ccv3.Query{{Key: ccv3.SpaceGUIDFilter, Values: []string{"space-guid"}}})) + }) + It("propagates listing errors and warnings", func() { + denied := errors.New("denied") + client.GetServiceAccountsReturns(nil, ccv3.Warnings{"warning"}, denied) + _, warnings, err := actor.GetServiceAccountsInSpace("space-guid") + Expect(err).To(MatchError(denied)) + Expect(warnings).To(ConsistOf("warning")) + }) + It("creates in the specified space and preserves platform state and warnings", func() { + created := resources.ServiceAccount{GUID: "account-guid", Status: "unprovisioned"} + client.CreateServiceAccountReturns(created, ccv3.Warnings{"warning"}, nil) + account, warnings, err := actor.CreateServiceAccountInSpace("shared-worker", "Workers", "space-guid") + Expect(err).NotTo(HaveOccurred()) + Expect(account).To(Equal(created)) + Expect(warnings).To(ConsistOf("warning")) + Expect(client.CreateServiceAccountCallCount()).To(Equal(1)) + Expect(client.CreateServiceAccountArgsForCall(0)).To(Equal(resources.ServiceAccount{ + Name: "shared-worker", Description: "Workers", Relationships: resources.Relationships{constant.RelationshipTypeSpace: {GUID: "space-guid"}}, + })) + }) + It("propagates errors and warnings without adopting an existing account", func() { + denied := errors.New("name permanently reserved") + client.CreateServiceAccountReturns(resources.ServiceAccount{}, ccv3.Warnings{"warning"}, denied) + _, warnings, err := actor.CreateServiceAccountInSpace("shared-worker", "", "space-guid") + Expect(err).To(MatchError(denied)) + Expect(warnings).To(ConsistOf("warning")) + }) +}) diff --git a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go index f8e3eaa7fd..c29b6118e9 100644 --- a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go +++ b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go @@ -16,11 +16,8 @@ import ( type FakeCloudControllerClient struct { ApplyOrganizationQuotaStub func(string, string) (resources.RelationshipList, ccv3.Warnings, error) applyOrganizationQuotaMutex sync.RWMutex - applyOrganizationQuotaArgsForCall []struct { - arg1 string - arg2 string - } - applyOrganizationQuotaReturns struct { + applyOrganizationQuotaArgsForCall []FakeCloudControllerClientApplyOrganizationQuotaArgs + applyOrganizationQuotaReturns struct { result1 resources.RelationshipList result2 ccv3.Warnings result3 error @@ -32,11 +29,8 @@ type FakeCloudControllerClient struct { } ApplySpaceQuotaStub func(string, string) (resources.RelationshipList, ccv3.Warnings, error) applySpaceQuotaMutex sync.RWMutex - applySpaceQuotaArgsForCall []struct { - arg1 string - arg2 string - } - applySpaceQuotaReturns struct { + applySpaceQuotaArgsForCall []FakeCloudControllerClientApplySpaceQuotaArgs + applySpaceQuotaReturns struct { result1 resources.RelationshipList result2 ccv3.Warnings result3 error @@ -48,10 +42,8 @@ type FakeCloudControllerClient struct { } CancelDeploymentStub func(string) (ccv3.Warnings, error) cancelDeploymentMutex sync.RWMutex - cancelDeploymentArgsForCall []struct { - arg1 string - } - cancelDeploymentReturns struct { + cancelDeploymentArgsForCall []FakeCloudControllerClientCancelDeploymentArgs + cancelDeploymentReturns struct { result1 ccv3.Warnings result2 error } @@ -61,13 +53,8 @@ type FakeCloudControllerClient struct { } CheckRouteStub func(string, string, string, int) (bool, ccv3.Warnings, error) checkRouteMutex sync.RWMutex - checkRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - checkRouteReturns struct { + checkRouteArgsForCall []FakeCloudControllerClientCheckRouteArgs + checkRouteReturns struct { result1 bool result2 ccv3.Warnings result3 error @@ -79,10 +66,8 @@ type FakeCloudControllerClient struct { } ContinueDeploymentStub func(string) (ccv3.Warnings, error) continueDeploymentMutex sync.RWMutex - continueDeploymentArgsForCall []struct { - arg1 string - } - continueDeploymentReturns struct { + continueDeploymentArgsForCall []FakeCloudControllerClientContinueDeploymentArgs + continueDeploymentReturns struct { result1 ccv3.Warnings result2 error } @@ -92,11 +77,8 @@ type FakeCloudControllerClient struct { } CopyPackageStub func(string, string) (resources.Package, ccv3.Warnings, error) copyPackageMutex sync.RWMutex - copyPackageArgsForCall []struct { - arg1 string - arg2 string - } - copyPackageReturns struct { + copyPackageArgsForCall []FakeCloudControllerClientCopyPackageArgs + copyPackageReturns struct { result1 resources.Package result2 ccv3.Warnings result3 error @@ -108,10 +90,8 @@ type FakeCloudControllerClient struct { } CreateApplicationStub func(resources.Application) (resources.Application, ccv3.Warnings, error) createApplicationMutex sync.RWMutex - createApplicationArgsForCall []struct { - arg1 resources.Application - } - createApplicationReturns struct { + createApplicationArgsForCall []FakeCloudControllerClientCreateApplicationArgs + createApplicationReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -123,10 +103,8 @@ type FakeCloudControllerClient struct { } CreateApplicationDeploymentStub func(resources.Deployment) (string, ccv3.Warnings, error) createApplicationDeploymentMutex sync.RWMutex - createApplicationDeploymentArgsForCall []struct { - arg1 resources.Deployment - } - createApplicationDeploymentReturns struct { + createApplicationDeploymentArgsForCall []FakeCloudControllerClientCreateApplicationDeploymentArgs + createApplicationDeploymentReturns struct { result1 string result2 ccv3.Warnings result3 error @@ -138,11 +116,8 @@ type FakeCloudControllerClient struct { } CreateApplicationProcessScaleStub func(string, resources.Process) (resources.Process, ccv3.Warnings, error) createApplicationProcessScaleMutex sync.RWMutex - createApplicationProcessScaleArgsForCall []struct { - arg1 string - arg2 resources.Process - } - createApplicationProcessScaleReturns struct { + createApplicationProcessScaleArgsForCall []FakeCloudControllerClientCreateApplicationProcessScaleArgs + createApplicationProcessScaleReturns struct { result1 resources.Process result2 ccv3.Warnings result3 error @@ -154,11 +129,8 @@ type FakeCloudControllerClient struct { } CreateApplicationTaskStub func(string, resources.Task) (resources.Task, ccv3.Warnings, error) createApplicationTaskMutex sync.RWMutex - createApplicationTaskArgsForCall []struct { - arg1 string - arg2 resources.Task - } - createApplicationTaskReturns struct { + createApplicationTaskArgsForCall []FakeCloudControllerClientCreateApplicationTaskArgs + createApplicationTaskReturns struct { result1 resources.Task result2 ccv3.Warnings result3 error @@ -170,10 +142,8 @@ type FakeCloudControllerClient struct { } CreateBuildStub func(resources.Build) (resources.Build, ccv3.Warnings, error) createBuildMutex sync.RWMutex - createBuildArgsForCall []struct { - arg1 resources.Build - } - createBuildReturns struct { + createBuildArgsForCall []FakeCloudControllerClientCreateBuildArgs + createBuildReturns struct { result1 resources.Build result2 ccv3.Warnings result3 error @@ -185,10 +155,8 @@ type FakeCloudControllerClient struct { } CreateBuildpackStub func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) createBuildpackMutex sync.RWMutex - createBuildpackArgsForCall []struct { - arg1 resources.Buildpack - } - createBuildpackReturns struct { + createBuildpackArgsForCall []FakeCloudControllerClientCreateBuildpackArgs + createBuildpackReturns struct { result1 resources.Buildpack result2 ccv3.Warnings result3 error @@ -200,10 +168,8 @@ type FakeCloudControllerClient struct { } CreateDomainStub func(resources.Domain) (resources.Domain, ccv3.Warnings, error) createDomainMutex sync.RWMutex - createDomainArgsForCall []struct { - arg1 resources.Domain - } - createDomainReturns struct { + createDomainArgsForCall []FakeCloudControllerClientCreateDomainArgs + createDomainReturns struct { result1 resources.Domain result2 ccv3.Warnings result3 error @@ -215,10 +181,8 @@ type FakeCloudControllerClient struct { } CreateDropletStub func(string) (resources.Droplet, ccv3.Warnings, error) createDropletMutex sync.RWMutex - createDropletArgsForCall []struct { - arg1 string - } - createDropletReturns struct { + createDropletArgsForCall []FakeCloudControllerClientCreateDropletArgs + createDropletReturns struct { result1 resources.Droplet result2 ccv3.Warnings result3 error @@ -230,10 +194,8 @@ type FakeCloudControllerClient struct { } CreateIsolationSegmentStub func(resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error) createIsolationSegmentMutex sync.RWMutex - createIsolationSegmentArgsForCall []struct { - arg1 resources.IsolationSegment - } - createIsolationSegmentReturns struct { + createIsolationSegmentArgsForCall []FakeCloudControllerClientCreateIsolationSegmentArgs + createIsolationSegmentReturns struct { result1 resources.IsolationSegment result2 ccv3.Warnings result3 error @@ -245,10 +207,8 @@ type FakeCloudControllerClient struct { } CreateOrganizationStub func(string) (resources.Organization, ccv3.Warnings, error) createOrganizationMutex sync.RWMutex - createOrganizationArgsForCall []struct { - arg1 string - } - createOrganizationReturns struct { + createOrganizationArgsForCall []FakeCloudControllerClientCreateOrganizationArgs + createOrganizationReturns struct { result1 resources.Organization result2 ccv3.Warnings result3 error @@ -260,10 +220,8 @@ type FakeCloudControllerClient struct { } CreateOrganizationQuotaStub func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) createOrganizationQuotaMutex sync.RWMutex - createOrganizationQuotaArgsForCall []struct { - arg1 resources.OrganizationQuota - } - createOrganizationQuotaReturns struct { + createOrganizationQuotaArgsForCall []FakeCloudControllerClientCreateOrganizationQuotaArgs + createOrganizationQuotaReturns struct { result1 resources.OrganizationQuota result2 ccv3.Warnings result3 error @@ -275,10 +233,8 @@ type FakeCloudControllerClient struct { } CreatePackageStub func(resources.Package) (resources.Package, ccv3.Warnings, error) createPackageMutex sync.RWMutex - createPackageArgsForCall []struct { - arg1 resources.Package - } - createPackageReturns struct { + createPackageArgsForCall []FakeCloudControllerClientCreatePackageArgs + createPackageReturns struct { result1 resources.Package result2 ccv3.Warnings result3 error @@ -290,10 +246,8 @@ type FakeCloudControllerClient struct { } CreateRoleStub func(resources.Role) (resources.Role, ccv3.Warnings, error) createRoleMutex sync.RWMutex - createRoleArgsForCall []struct { - arg1 resources.Role - } - createRoleReturns struct { + createRoleArgsForCall []FakeCloudControllerClientCreateRoleArgs + createRoleReturns struct { result1 resources.Role result2 ccv3.Warnings result3 error @@ -305,10 +259,8 @@ type FakeCloudControllerClient struct { } CreateRouteStub func(resources.Route) (resources.Route, ccv3.Warnings, error) createRouteMutex sync.RWMutex - createRouteArgsForCall []struct { - arg1 resources.Route - } - createRouteReturns struct { + createRouteArgsForCall []FakeCloudControllerClientCreateRouteArgs + createRouteReturns struct { result1 resources.Route result2 ccv3.Warnings result3 error @@ -320,10 +272,8 @@ type FakeCloudControllerClient struct { } CreateRouteBindingStub func(resources.RouteBinding) (ccv3.JobURL, ccv3.Warnings, error) createRouteBindingMutex sync.RWMutex - createRouteBindingArgsForCall []struct { - arg1 resources.RouteBinding - } - createRouteBindingReturns struct { + createRouteBindingArgsForCall []FakeCloudControllerClientCreateRouteBindingArgs + createRouteBindingReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -335,10 +285,8 @@ type FakeCloudControllerClient struct { } CreateRoutePolicyStub func(resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error) createRoutePolicyMutex sync.RWMutex - createRoutePolicyArgsForCall []struct { - arg1 resources.RoutePolicy - } - createRoutePolicyReturns struct { + createRoutePolicyArgsForCall []FakeCloudControllerClientCreateRoutePolicyArgs + createRoutePolicyReturns struct { result1 resources.RoutePolicy result2 ccv3.Warnings result3 error @@ -350,10 +298,8 @@ type FakeCloudControllerClient struct { } CreateSecurityGroupStub func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) createSecurityGroupMutex sync.RWMutex - createSecurityGroupArgsForCall []struct { - arg1 resources.SecurityGroup - } - createSecurityGroupReturns struct { + createSecurityGroupArgsForCall []FakeCloudControllerClientCreateSecurityGroupArgs + createSecurityGroupReturns struct { result1 resources.SecurityGroup result2 ccv3.Warnings result3 error @@ -363,12 +309,23 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + CreateServiceAccountStub func(resources.ServiceAccount) (resources.ServiceAccount, ccv3.Warnings, error) + createServiceAccountMutex sync.RWMutex + createServiceAccountArgsForCall []FakeCloudControllerClientCreateServiceAccountArgs + createServiceAccountReturns struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } + createServiceAccountReturnsOnCall map[int]struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } CreateServiceBrokerStub func(resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) createServiceBrokerMutex sync.RWMutex - createServiceBrokerArgsForCall []struct { - arg1 resources.ServiceBroker - } - createServiceBrokerReturns struct { + createServiceBrokerArgsForCall []FakeCloudControllerClientCreateServiceBrokerArgs + createServiceBrokerReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -380,10 +337,8 @@ type FakeCloudControllerClient struct { } CreateServiceCredentialBindingStub func(resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error) createServiceCredentialBindingMutex sync.RWMutex - createServiceCredentialBindingArgsForCall []struct { - arg1 resources.ServiceCredentialBinding - } - createServiceCredentialBindingReturns struct { + createServiceCredentialBindingArgsForCall []FakeCloudControllerClientCreateServiceCredentialBindingArgs + createServiceCredentialBindingReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -395,10 +350,8 @@ type FakeCloudControllerClient struct { } CreateServiceInstanceStub func(resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) createServiceInstanceMutex sync.RWMutex - createServiceInstanceArgsForCall []struct { - arg1 resources.ServiceInstance - } - createServiceInstanceReturns struct { + createServiceInstanceArgsForCall []FakeCloudControllerClientCreateServiceInstanceArgs + createServiceInstanceReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -410,10 +363,8 @@ type FakeCloudControllerClient struct { } CreateSpaceStub func(resources.Space) (resources.Space, ccv3.Warnings, error) createSpaceMutex sync.RWMutex - createSpaceArgsForCall []struct { - arg1 resources.Space - } - createSpaceReturns struct { + createSpaceArgsForCall []FakeCloudControllerClientCreateSpaceArgs + createSpaceReturns struct { result1 resources.Space result2 ccv3.Warnings result3 error @@ -425,10 +376,8 @@ type FakeCloudControllerClient struct { } CreateSpaceQuotaStub func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) createSpaceQuotaMutex sync.RWMutex - createSpaceQuotaArgsForCall []struct { - arg1 resources.SpaceQuota - } - createSpaceQuotaReturns struct { + createSpaceQuotaArgsForCall []FakeCloudControllerClientCreateSpaceQuotaArgs + createSpaceQuotaReturns struct { result1 resources.SpaceQuota result2 ccv3.Warnings result3 error @@ -440,10 +389,8 @@ type FakeCloudControllerClient struct { } CreateUserStub func(string) (resources.User, ccv3.Warnings, error) createUserMutex sync.RWMutex - createUserArgsForCall []struct { - arg1 string - } - createUserReturns struct { + createUserArgsForCall []FakeCloudControllerClientCreateUserArgs + createUserReturns struct { result1 resources.User result2 ccv3.Warnings result3 error @@ -455,10 +402,8 @@ type FakeCloudControllerClient struct { } DeleteApplicationStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteApplicationMutex sync.RWMutex - deleteApplicationArgsForCall []struct { - arg1 string - } - deleteApplicationReturns struct { + deleteApplicationArgsForCall []FakeCloudControllerClientDeleteApplicationArgs + deleteApplicationReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -470,12 +415,8 @@ type FakeCloudControllerClient struct { } DeleteApplicationProcessInstanceStub func(string, string, int) (ccv3.Warnings, error) deleteApplicationProcessInstanceMutex sync.RWMutex - deleteApplicationProcessInstanceArgsForCall []struct { - arg1 string - arg2 string - arg3 int - } - deleteApplicationProcessInstanceReturns struct { + deleteApplicationProcessInstanceArgsForCall []FakeCloudControllerClientDeleteApplicationProcessInstanceArgs + deleteApplicationProcessInstanceReturns struct { result1 ccv3.Warnings result2 error } @@ -485,10 +426,8 @@ type FakeCloudControllerClient struct { } DeleteBuildpackStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteBuildpackMutex sync.RWMutex - deleteBuildpackArgsForCall []struct { - arg1 string - } - deleteBuildpackReturns struct { + deleteBuildpackArgsForCall []FakeCloudControllerClientDeleteBuildpackArgs + deleteBuildpackReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -500,10 +439,8 @@ type FakeCloudControllerClient struct { } DeleteDomainStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteDomainMutex sync.RWMutex - deleteDomainArgsForCall []struct { - arg1 string - } - deleteDomainReturns struct { + deleteDomainArgsForCall []FakeCloudControllerClientDeleteDomainArgs + deleteDomainReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -515,10 +452,8 @@ type FakeCloudControllerClient struct { } DeleteIsolationSegmentStub func(string) (ccv3.Warnings, error) deleteIsolationSegmentMutex sync.RWMutex - deleteIsolationSegmentArgsForCall []struct { - arg1 string - } - deleteIsolationSegmentReturns struct { + deleteIsolationSegmentArgsForCall []FakeCloudControllerClientDeleteIsolationSegmentArgs + deleteIsolationSegmentReturns struct { result1 ccv3.Warnings result2 error } @@ -528,11 +463,8 @@ type FakeCloudControllerClient struct { } DeleteIsolationSegmentOrganizationStub func(string, string) (ccv3.Warnings, error) deleteIsolationSegmentOrganizationMutex sync.RWMutex - deleteIsolationSegmentOrganizationArgsForCall []struct { - arg1 string - arg2 string - } - deleteIsolationSegmentOrganizationReturns struct { + deleteIsolationSegmentOrganizationArgsForCall []FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs + deleteIsolationSegmentOrganizationReturns struct { result1 ccv3.Warnings result2 error } @@ -542,10 +474,8 @@ type FakeCloudControllerClient struct { } DeleteOrganizationStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteOrganizationMutex sync.RWMutex - deleteOrganizationArgsForCall []struct { - arg1 string - } - deleteOrganizationReturns struct { + deleteOrganizationArgsForCall []FakeCloudControllerClientDeleteOrganizationArgs + deleteOrganizationReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -557,10 +487,8 @@ type FakeCloudControllerClient struct { } DeleteOrganizationQuotaStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteOrganizationQuotaMutex sync.RWMutex - deleteOrganizationQuotaArgsForCall []struct { - arg1 string - } - deleteOrganizationQuotaReturns struct { + deleteOrganizationQuotaArgsForCall []FakeCloudControllerClientDeleteOrganizationQuotaArgs + deleteOrganizationQuotaReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -572,10 +500,8 @@ type FakeCloudControllerClient struct { } DeleteOrphanedRoutesStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteOrphanedRoutesMutex sync.RWMutex - deleteOrphanedRoutesArgsForCall []struct { - arg1 string - } - deleteOrphanedRoutesReturns struct { + deleteOrphanedRoutesArgsForCall []FakeCloudControllerClientDeleteOrphanedRoutesArgs + deleteOrphanedRoutesReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -587,10 +513,8 @@ type FakeCloudControllerClient struct { } DeleteRoleStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteRoleMutex sync.RWMutex - deleteRoleArgsForCall []struct { - arg1 string - } - deleteRoleReturns struct { + deleteRoleArgsForCall []FakeCloudControllerClientDeleteRoleArgs + deleteRoleReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -602,10 +526,8 @@ type FakeCloudControllerClient struct { } DeleteRouteStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteRouteMutex sync.RWMutex - deleteRouteArgsForCall []struct { - arg1 string - } - deleteRouteReturns struct { + deleteRouteArgsForCall []FakeCloudControllerClientDeleteRouteArgs + deleteRouteReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -617,10 +539,8 @@ type FakeCloudControllerClient struct { } DeleteRouteBindingStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteRouteBindingMutex sync.RWMutex - deleteRouteBindingArgsForCall []struct { - arg1 string - } - deleteRouteBindingReturns struct { + deleteRouteBindingArgsForCall []FakeCloudControllerClientDeleteRouteBindingArgs + deleteRouteBindingReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -632,10 +552,8 @@ type FakeCloudControllerClient struct { } DeleteRoutePolicyStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteRoutePolicyMutex sync.RWMutex - deleteRoutePolicyArgsForCall []struct { - arg1 string - } - deleteRoutePolicyReturns struct { + deleteRoutePolicyArgsForCall []FakeCloudControllerClientDeleteRoutePolicyArgs + deleteRoutePolicyReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -647,10 +565,8 @@ type FakeCloudControllerClient struct { } DeleteSecurityGroupStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteSecurityGroupMutex sync.RWMutex - deleteSecurityGroupArgsForCall []struct { - arg1 string - } - deleteSecurityGroupReturns struct { + deleteSecurityGroupArgsForCall []FakeCloudControllerClientDeleteSecurityGroupArgs + deleteSecurityGroupReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -660,12 +576,23 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + DeleteServiceAccountStub func(string) (ccv3.JobURL, ccv3.Warnings, error) + deleteServiceAccountMutex sync.RWMutex + deleteServiceAccountArgsForCall []FakeCloudControllerClientDeleteServiceAccountArgs + deleteServiceAccountReturns struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } + deleteServiceAccountReturnsOnCall map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } DeleteServiceBrokerStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteServiceBrokerMutex sync.RWMutex - deleteServiceBrokerArgsForCall []struct { - arg1 string - } - deleteServiceBrokerReturns struct { + deleteServiceBrokerArgsForCall []FakeCloudControllerClientDeleteServiceBrokerArgs + deleteServiceBrokerReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -677,10 +604,8 @@ type FakeCloudControllerClient struct { } DeleteServiceCredentialBindingStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteServiceCredentialBindingMutex sync.RWMutex - deleteServiceCredentialBindingArgsForCall []struct { - arg1 string - } - deleteServiceCredentialBindingReturns struct { + deleteServiceCredentialBindingArgsForCall []FakeCloudControllerClientDeleteServiceCredentialBindingArgs + deleteServiceCredentialBindingReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -692,11 +617,8 @@ type FakeCloudControllerClient struct { } DeleteServiceInstanceStub func(string, ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error) deleteServiceInstanceMutex sync.RWMutex - deleteServiceInstanceArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - deleteServiceInstanceReturns struct { + deleteServiceInstanceArgsForCall []FakeCloudControllerClientDeleteServiceInstanceArgs + deleteServiceInstanceReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -708,11 +630,8 @@ type FakeCloudControllerClient struct { } DeleteServicePlanVisibilityStub func(string, string) (ccv3.Warnings, error) deleteServicePlanVisibilityMutex sync.RWMutex - deleteServicePlanVisibilityArgsForCall []struct { - arg1 string - arg2 string - } - deleteServicePlanVisibilityReturns struct { + deleteServicePlanVisibilityArgsForCall []FakeCloudControllerClientDeleteServicePlanVisibilityArgs + deleteServicePlanVisibilityReturns struct { result1 ccv3.Warnings result2 error } @@ -722,10 +641,8 @@ type FakeCloudControllerClient struct { } DeleteSpaceStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteSpaceMutex sync.RWMutex - deleteSpaceArgsForCall []struct { - arg1 string - } - deleteSpaceReturns struct { + deleteSpaceArgsForCall []FakeCloudControllerClientDeleteSpaceArgs + deleteSpaceReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -737,10 +654,8 @@ type FakeCloudControllerClient struct { } DeleteSpaceQuotaStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteSpaceQuotaMutex sync.RWMutex - deleteSpaceQuotaArgsForCall []struct { - arg1 string - } - deleteSpaceQuotaReturns struct { + deleteSpaceQuotaArgsForCall []FakeCloudControllerClientDeleteSpaceQuotaArgs + deleteSpaceQuotaReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -752,10 +667,8 @@ type FakeCloudControllerClient struct { } DeleteUserStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteUserMutex sync.RWMutex - deleteUserArgsForCall []struct { - arg1 string - } - deleteUserReturns struct { + deleteUserArgsForCall []FakeCloudControllerClientDeleteUserArgs + deleteUserReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -767,10 +680,8 @@ type FakeCloudControllerClient struct { } DownloadDropletStub func(string) ([]byte, ccv3.Warnings, error) downloadDropletMutex sync.RWMutex - downloadDropletArgsForCall []struct { - arg1 string - } - downloadDropletReturns struct { + downloadDropletArgsForCall []FakeCloudControllerClientDownloadDropletArgs + downloadDropletReturns struct { result1 []byte result2 ccv3.Warnings result3 error @@ -782,11 +693,8 @@ type FakeCloudControllerClient struct { } EntitleIsolationSegmentToOrganizationsStub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error) entitleIsolationSegmentToOrganizationsMutex sync.RWMutex - entitleIsolationSegmentToOrganizationsArgsForCall []struct { - arg1 string - arg2 []string - } - entitleIsolationSegmentToOrganizationsReturns struct { + entitleIsolationSegmentToOrganizationsArgsForCall []FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs + entitleIsolationSegmentToOrganizationsReturns struct { result1 resources.RelationshipList result2 ccv3.Warnings result3 error @@ -798,11 +706,8 @@ type FakeCloudControllerClient struct { } GetAppFeatureStub func(string, string) (resources.ApplicationFeature, ccv3.Warnings, error) getAppFeatureMutex sync.RWMutex - getAppFeatureArgsForCall []struct { - arg1 string - arg2 string - } - getAppFeatureReturns struct { + getAppFeatureArgsForCall []FakeCloudControllerClientGetAppFeatureArgs + getAppFeatureReturns struct { result1 resources.ApplicationFeature result2 ccv3.Warnings result3 error @@ -814,11 +719,8 @@ type FakeCloudControllerClient struct { } GetApplicationByNameAndSpaceStub func(string, string) (resources.Application, ccv3.Warnings, error) getApplicationByNameAndSpaceMutex sync.RWMutex - getApplicationByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationByNameAndSpaceReturns struct { + getApplicationByNameAndSpaceArgsForCall []FakeCloudControllerClientGetApplicationByNameAndSpaceArgs + getApplicationByNameAndSpaceReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -830,10 +732,8 @@ type FakeCloudControllerClient struct { } GetApplicationDropletCurrentStub func(string) (resources.Droplet, ccv3.Warnings, error) getApplicationDropletCurrentMutex sync.RWMutex - getApplicationDropletCurrentArgsForCall []struct { - arg1 string - } - getApplicationDropletCurrentReturns struct { + getApplicationDropletCurrentArgsForCall []FakeCloudControllerClientGetApplicationDropletCurrentArgs + getApplicationDropletCurrentReturns struct { result1 resources.Droplet result2 ccv3.Warnings result3 error @@ -845,10 +745,8 @@ type FakeCloudControllerClient struct { } GetApplicationEnvironmentStub func(string) (ccv3.Environment, ccv3.Warnings, error) getApplicationEnvironmentMutex sync.RWMutex - getApplicationEnvironmentArgsForCall []struct { - arg1 string - } - getApplicationEnvironmentReturns struct { + getApplicationEnvironmentArgsForCall []FakeCloudControllerClientGetApplicationEnvironmentArgs + getApplicationEnvironmentReturns struct { result1 ccv3.Environment result2 ccv3.Warnings result3 error @@ -860,10 +758,8 @@ type FakeCloudControllerClient struct { } GetApplicationManifestStub func(string) ([]byte, ccv3.Warnings, error) getApplicationManifestMutex sync.RWMutex - getApplicationManifestArgsForCall []struct { - arg1 string - } - getApplicationManifestReturns struct { + getApplicationManifestArgsForCall []FakeCloudControllerClientGetApplicationManifestArgs + getApplicationManifestReturns struct { result1 []byte result2 ccv3.Warnings result3 error @@ -875,11 +771,8 @@ type FakeCloudControllerClient struct { } GetApplicationProcessByTypeStub func(string, string) (resources.Process, ccv3.Warnings, error) getApplicationProcessByTypeMutex sync.RWMutex - getApplicationProcessByTypeArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationProcessByTypeReturns struct { + getApplicationProcessByTypeArgsForCall []FakeCloudControllerClientGetApplicationProcessByTypeArgs + getApplicationProcessByTypeReturns struct { result1 resources.Process result2 ccv3.Warnings result3 error @@ -891,10 +784,8 @@ type FakeCloudControllerClient struct { } GetApplicationProcessesStub func(string) ([]resources.Process, ccv3.Warnings, error) getApplicationProcessesMutex sync.RWMutex - getApplicationProcessesArgsForCall []struct { - arg1 string - } - getApplicationProcessesReturns struct { + getApplicationProcessesArgsForCall []FakeCloudControllerClientGetApplicationProcessesArgs + getApplicationProcessesReturns struct { result1 []resources.Process result2 ccv3.Warnings result3 error @@ -906,11 +797,8 @@ type FakeCloudControllerClient struct { } GetApplicationRevisionsStub func(string, ...ccv3.Query) ([]resources.Revision, ccv3.Warnings, error) getApplicationRevisionsMutex sync.RWMutex - getApplicationRevisionsArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getApplicationRevisionsReturns struct { + getApplicationRevisionsArgsForCall []FakeCloudControllerClientGetApplicationRevisionsArgs + getApplicationRevisionsReturns struct { result1 []resources.Revision result2 ccv3.Warnings result3 error @@ -922,10 +810,8 @@ type FakeCloudControllerClient struct { } GetApplicationRevisionsDeployedStub func(string) ([]resources.Revision, ccv3.Warnings, error) getApplicationRevisionsDeployedMutex sync.RWMutex - getApplicationRevisionsDeployedArgsForCall []struct { - arg1 string - } - getApplicationRevisionsDeployedReturns struct { + getApplicationRevisionsDeployedArgsForCall []FakeCloudControllerClientGetApplicationRevisionsDeployedArgs + getApplicationRevisionsDeployedReturns struct { result1 []resources.Revision result2 ccv3.Warnings result3 error @@ -937,10 +823,8 @@ type FakeCloudControllerClient struct { } GetApplicationRoutesStub func(string) ([]resources.Route, ccv3.Warnings, error) getApplicationRoutesMutex sync.RWMutex - getApplicationRoutesArgsForCall []struct { - arg1 string - } - getApplicationRoutesReturns struct { + getApplicationRoutesArgsForCall []FakeCloudControllerClientGetApplicationRoutesArgs + getApplicationRoutesReturns struct { result1 []resources.Route result2 ccv3.Warnings result3 error @@ -952,11 +836,8 @@ type FakeCloudControllerClient struct { } GetApplicationTasksStub func(string, ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error) getApplicationTasksMutex sync.RWMutex - getApplicationTasksArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getApplicationTasksReturns struct { + getApplicationTasksArgsForCall []FakeCloudControllerClientGetApplicationTasksArgs + getApplicationTasksReturns struct { result1 []resources.Task result2 ccv3.Warnings result3 error @@ -968,10 +849,8 @@ type FakeCloudControllerClient struct { } GetApplicationsStub func(...ccv3.Query) ([]resources.Application, ccv3.Warnings, error) getApplicationsMutex sync.RWMutex - getApplicationsArgsForCall []struct { - arg1 []ccv3.Query - } - getApplicationsReturns struct { + getApplicationsArgsForCall []FakeCloudControllerClientGetApplicationsArgs + getApplicationsReturns struct { result1 []resources.Application result2 ccv3.Warnings result3 error @@ -983,10 +862,8 @@ type FakeCloudControllerClient struct { } GetBuildStub func(string) (resources.Build, ccv3.Warnings, error) getBuildMutex sync.RWMutex - getBuildArgsForCall []struct { - arg1 string - } - getBuildReturns struct { + getBuildArgsForCall []FakeCloudControllerClientGetBuildArgs + getBuildReturns struct { result1 resources.Build result2 ccv3.Warnings result3 error @@ -998,10 +875,8 @@ type FakeCloudControllerClient struct { } GetBuildpacksStub func(...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error) getBuildpacksMutex sync.RWMutex - getBuildpacksArgsForCall []struct { - arg1 []ccv3.Query - } - getBuildpacksReturns struct { + getBuildpacksArgsForCall []FakeCloudControllerClientGetBuildpacksArgs + getBuildpacksReturns struct { result1 []resources.Buildpack result2 ccv3.Warnings result3 error @@ -1013,10 +888,8 @@ type FakeCloudControllerClient struct { } GetDefaultDomainStub func(string) (resources.Domain, ccv3.Warnings, error) getDefaultDomainMutex sync.RWMutex - getDefaultDomainArgsForCall []struct { - arg1 string - } - getDefaultDomainReturns struct { + getDefaultDomainArgsForCall []FakeCloudControllerClientGetDefaultDomainArgs + getDefaultDomainReturns struct { result1 resources.Domain result2 ccv3.Warnings result3 error @@ -1028,10 +901,8 @@ type FakeCloudControllerClient struct { } GetDeploymentStub func(string) (resources.Deployment, ccv3.Warnings, error) getDeploymentMutex sync.RWMutex - getDeploymentArgsForCall []struct { - arg1 string - } - getDeploymentReturns struct { + getDeploymentArgsForCall []FakeCloudControllerClientGetDeploymentArgs + getDeploymentReturns struct { result1 resources.Deployment result2 ccv3.Warnings result3 error @@ -1043,10 +914,8 @@ type FakeCloudControllerClient struct { } GetDeploymentsStub func(...ccv3.Query) ([]resources.Deployment, ccv3.Warnings, error) getDeploymentsMutex sync.RWMutex - getDeploymentsArgsForCall []struct { - arg1 []ccv3.Query - } - getDeploymentsReturns struct { + getDeploymentsArgsForCall []FakeCloudControllerClientGetDeploymentsArgs + getDeploymentsReturns struct { result1 []resources.Deployment result2 ccv3.Warnings result3 error @@ -1058,10 +927,8 @@ type FakeCloudControllerClient struct { } GetDomainStub func(string) (resources.Domain, ccv3.Warnings, error) getDomainMutex sync.RWMutex - getDomainArgsForCall []struct { - arg1 string - } - getDomainReturns struct { + getDomainArgsForCall []FakeCloudControllerClientGetDomainArgs + getDomainReturns struct { result1 resources.Domain result2 ccv3.Warnings result3 error @@ -1073,10 +940,8 @@ type FakeCloudControllerClient struct { } GetDomainsStub func(...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) getDomainsMutex sync.RWMutex - getDomainsArgsForCall []struct { - arg1 []ccv3.Query - } - getDomainsReturns struct { + getDomainsArgsForCall []FakeCloudControllerClientGetDomainsArgs + getDomainsReturns struct { result1 []resources.Domain result2 ccv3.Warnings result3 error @@ -1088,10 +953,8 @@ type FakeCloudControllerClient struct { } GetDropletStub func(string) (resources.Droplet, ccv3.Warnings, error) getDropletMutex sync.RWMutex - getDropletArgsForCall []struct { - arg1 string - } - getDropletReturns struct { + getDropletArgsForCall []FakeCloudControllerClientGetDropletArgs + getDropletReturns struct { result1 resources.Droplet result2 ccv3.Warnings result3 error @@ -1103,10 +966,8 @@ type FakeCloudControllerClient struct { } GetDropletsStub func(...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) getDropletsMutex sync.RWMutex - getDropletsArgsForCall []struct { - arg1 []ccv3.Query - } - getDropletsReturns struct { + getDropletsArgsForCall []FakeCloudControllerClientGetDropletsArgs + getDropletsReturns struct { result1 []resources.Droplet result2 ccv3.Warnings result3 error @@ -1118,10 +979,8 @@ type FakeCloudControllerClient struct { } GetEnvironmentVariableGroupStub func(constant.EnvironmentVariableGroupName) (resources.EnvironmentVariables, ccv3.Warnings, error) getEnvironmentVariableGroupMutex sync.RWMutex - getEnvironmentVariableGroupArgsForCall []struct { - arg1 constant.EnvironmentVariableGroupName - } - getEnvironmentVariableGroupReturns struct { + getEnvironmentVariableGroupArgsForCall []FakeCloudControllerClientGetEnvironmentVariableGroupArgs + getEnvironmentVariableGroupReturns struct { result1 resources.EnvironmentVariables result2 ccv3.Warnings result3 error @@ -1133,10 +992,8 @@ type FakeCloudControllerClient struct { } GetEnvironmentVariablesByURLStub func(string) (resources.EnvironmentVariables, ccv3.Warnings, error) getEnvironmentVariablesByURLMutex sync.RWMutex - getEnvironmentVariablesByURLArgsForCall []struct { - arg1 string - } - getEnvironmentVariablesByURLReturns struct { + getEnvironmentVariablesByURLArgsForCall []FakeCloudControllerClientGetEnvironmentVariablesByURLArgs + getEnvironmentVariablesByURLReturns struct { result1 resources.EnvironmentVariables result2 ccv3.Warnings result3 error @@ -1148,10 +1005,8 @@ type FakeCloudControllerClient struct { } GetEventsStub func(...ccv3.Query) ([]ccv3.Event, ccv3.Warnings, error) getEventsMutex sync.RWMutex - getEventsArgsForCall []struct { - arg1 []ccv3.Query - } - getEventsReturns struct { + getEventsArgsForCall []FakeCloudControllerClientGetEventsArgs + getEventsReturns struct { result1 []ccv3.Event result2 ccv3.Warnings result3 error @@ -1163,10 +1018,8 @@ type FakeCloudControllerClient struct { } GetFeatureFlagStub func(string) (resources.FeatureFlag, ccv3.Warnings, error) getFeatureFlagMutex sync.RWMutex - getFeatureFlagArgsForCall []struct { - arg1 string - } - getFeatureFlagReturns struct { + getFeatureFlagArgsForCall []FakeCloudControllerClientGetFeatureFlagArgs + getFeatureFlagReturns struct { result1 resources.FeatureFlag result2 ccv3.Warnings result3 error @@ -1178,9 +1031,8 @@ type FakeCloudControllerClient struct { } GetFeatureFlagsStub func() ([]resources.FeatureFlag, ccv3.Warnings, error) getFeatureFlagsMutex sync.RWMutex - getFeatureFlagsArgsForCall []struct { - } - getFeatureFlagsReturns struct { + getFeatureFlagsArgsForCall []struct{} + getFeatureFlagsReturns struct { result1 []resources.FeatureFlag result2 ccv3.Warnings result3 error @@ -1192,9 +1044,8 @@ type FakeCloudControllerClient struct { } GetInfoStub func() (ccv3.Info, ccv3.Warnings, error) getInfoMutex sync.RWMutex - getInfoArgsForCall []struct { - } - getInfoReturns struct { + getInfoArgsForCall []struct{} + getInfoReturns struct { result1 ccv3.Info result2 ccv3.Warnings result3 error @@ -1206,10 +1057,8 @@ type FakeCloudControllerClient struct { } GetIsolationSegmentStub func(string) (resources.IsolationSegment, ccv3.Warnings, error) getIsolationSegmentMutex sync.RWMutex - getIsolationSegmentArgsForCall []struct { - arg1 string - } - getIsolationSegmentReturns struct { + getIsolationSegmentArgsForCall []FakeCloudControllerClientGetIsolationSegmentArgs + getIsolationSegmentReturns struct { result1 resources.IsolationSegment result2 ccv3.Warnings result3 error @@ -1221,10 +1070,8 @@ type FakeCloudControllerClient struct { } GetIsolationSegmentOrganizationsStub func(string) ([]resources.Organization, ccv3.Warnings, error) getIsolationSegmentOrganizationsMutex sync.RWMutex - getIsolationSegmentOrganizationsArgsForCall []struct { - arg1 string - } - getIsolationSegmentOrganizationsReturns struct { + getIsolationSegmentOrganizationsArgsForCall []FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs + getIsolationSegmentOrganizationsReturns struct { result1 []resources.Organization result2 ccv3.Warnings result3 error @@ -1236,10 +1083,8 @@ type FakeCloudControllerClient struct { } GetIsolationSegmentsStub func(...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error) getIsolationSegmentsMutex sync.RWMutex - getIsolationSegmentsArgsForCall []struct { - arg1 []ccv3.Query - } - getIsolationSegmentsReturns struct { + getIsolationSegmentsArgsForCall []FakeCloudControllerClientGetIsolationSegmentsArgs + getIsolationSegmentsReturns struct { result1 []resources.IsolationSegment result2 ccv3.Warnings result3 error @@ -1251,11 +1096,8 @@ type FakeCloudControllerClient struct { } GetNewApplicationProcessesStub func(string, string) ([]resources.Process, ccv3.Warnings, error) getNewApplicationProcessesMutex sync.RWMutex - getNewApplicationProcessesArgsForCall []struct { - arg1 string - arg2 string - } - getNewApplicationProcessesReturns struct { + getNewApplicationProcessesArgsForCall []FakeCloudControllerClientGetNewApplicationProcessesArgs + getNewApplicationProcessesReturns struct { result1 []resources.Process result2 ccv3.Warnings result3 error @@ -1267,10 +1109,8 @@ type FakeCloudControllerClient struct { } GetOrganizationStub func(string) (resources.Organization, ccv3.Warnings, error) getOrganizationMutex sync.RWMutex - getOrganizationArgsForCall []struct { - arg1 string - } - getOrganizationReturns struct { + getOrganizationArgsForCall []FakeCloudControllerClientGetOrganizationArgs + getOrganizationReturns struct { result1 resources.Organization result2 ccv3.Warnings result3 error @@ -1282,10 +1122,8 @@ type FakeCloudControllerClient struct { } GetOrganizationDefaultIsolationSegmentStub func(string) (resources.Relationship, ccv3.Warnings, error) getOrganizationDefaultIsolationSegmentMutex sync.RWMutex - getOrganizationDefaultIsolationSegmentArgsForCall []struct { - arg1 string - } - getOrganizationDefaultIsolationSegmentReturns struct { + getOrganizationDefaultIsolationSegmentArgsForCall []FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs + getOrganizationDefaultIsolationSegmentReturns struct { result1 resources.Relationship result2 ccv3.Warnings result3 error @@ -1297,11 +1135,8 @@ type FakeCloudControllerClient struct { } GetOrganizationDomainsStub func(string, ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) getOrganizationDomainsMutex sync.RWMutex - getOrganizationDomainsArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getOrganizationDomainsReturns struct { + getOrganizationDomainsArgsForCall []FakeCloudControllerClientGetOrganizationDomainsArgs + getOrganizationDomainsReturns struct { result1 []resources.Domain result2 ccv3.Warnings result3 error @@ -1313,10 +1148,8 @@ type FakeCloudControllerClient struct { } GetOrganizationQuotaStub func(string) (resources.OrganizationQuota, ccv3.Warnings, error) getOrganizationQuotaMutex sync.RWMutex - getOrganizationQuotaArgsForCall []struct { - arg1 string - } - getOrganizationQuotaReturns struct { + getOrganizationQuotaArgsForCall []FakeCloudControllerClientGetOrganizationQuotaArgs + getOrganizationQuotaReturns struct { result1 resources.OrganizationQuota result2 ccv3.Warnings result3 error @@ -1328,10 +1161,8 @@ type FakeCloudControllerClient struct { } GetOrganizationQuotasStub func(...ccv3.Query) ([]resources.OrganizationQuota, ccv3.Warnings, error) getOrganizationQuotasMutex sync.RWMutex - getOrganizationQuotasArgsForCall []struct { - arg1 []ccv3.Query - } - getOrganizationQuotasReturns struct { + getOrganizationQuotasArgsForCall []FakeCloudControllerClientGetOrganizationQuotasArgs + getOrganizationQuotasReturns struct { result1 []resources.OrganizationQuota result2 ccv3.Warnings result3 error @@ -1343,10 +1174,8 @@ type FakeCloudControllerClient struct { } GetOrganizationsStub func(...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error) getOrganizationsMutex sync.RWMutex - getOrganizationsArgsForCall []struct { - arg1 []ccv3.Query - } - getOrganizationsReturns struct { + getOrganizationsArgsForCall []FakeCloudControllerClientGetOrganizationsArgs + getOrganizationsReturns struct { result1 []resources.Organization result2 ccv3.Warnings result3 error @@ -1358,10 +1187,8 @@ type FakeCloudControllerClient struct { } GetPackageStub func(string) (resources.Package, ccv3.Warnings, error) getPackageMutex sync.RWMutex - getPackageArgsForCall []struct { - arg1 string - } - getPackageReturns struct { + getPackageArgsForCall []FakeCloudControllerClientGetPackageArgs + getPackageReturns struct { result1 resources.Package result2 ccv3.Warnings result3 error @@ -1373,11 +1200,8 @@ type FakeCloudControllerClient struct { } GetPackageDropletsStub func(string, ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) getPackageDropletsMutex sync.RWMutex - getPackageDropletsArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getPackageDropletsReturns struct { + getPackageDropletsArgsForCall []FakeCloudControllerClientGetPackageDropletsArgs + getPackageDropletsReturns struct { result1 []resources.Droplet result2 ccv3.Warnings result3 error @@ -1389,10 +1213,8 @@ type FakeCloudControllerClient struct { } GetPackagesStub func(...ccv3.Query) ([]resources.Package, ccv3.Warnings, error) getPackagesMutex sync.RWMutex - getPackagesArgsForCall []struct { - arg1 []ccv3.Query - } - getPackagesReturns struct { + getPackagesArgsForCall []FakeCloudControllerClientGetPackagesArgs + getPackagesReturns struct { result1 []resources.Package result2 ccv3.Warnings result3 error @@ -1404,10 +1226,8 @@ type FakeCloudControllerClient struct { } GetProcessStub func(string) (resources.Process, ccv3.Warnings, error) getProcessMutex sync.RWMutex - getProcessArgsForCall []struct { - arg1 string - } - getProcessReturns struct { + getProcessArgsForCall []FakeCloudControllerClientGetProcessArgs + getProcessReturns struct { result1 resources.Process result2 ccv3.Warnings result3 error @@ -1419,10 +1239,8 @@ type FakeCloudControllerClient struct { } GetProcessInstancesStub func(string) ([]ccv3.ProcessInstance, ccv3.Warnings, error) getProcessInstancesMutex sync.RWMutex - getProcessInstancesArgsForCall []struct { - arg1 string - } - getProcessInstancesReturns struct { + getProcessInstancesArgsForCall []FakeCloudControllerClientGetProcessInstancesArgs + getProcessInstancesReturns struct { result1 []ccv3.ProcessInstance result2 ccv3.Warnings result3 error @@ -1434,10 +1252,8 @@ type FakeCloudControllerClient struct { } GetProcessSidecarsStub func(string) ([]resources.Sidecar, ccv3.Warnings, error) getProcessSidecarsMutex sync.RWMutex - getProcessSidecarsArgsForCall []struct { - arg1 string - } - getProcessSidecarsReturns struct { + getProcessSidecarsArgsForCall []FakeCloudControllerClientGetProcessSidecarsArgs + getProcessSidecarsReturns struct { result1 []resources.Sidecar result2 ccv3.Warnings result3 error @@ -1449,10 +1265,8 @@ type FakeCloudControllerClient struct { } GetProcessesStub func(...ccv3.Query) ([]resources.Process, ccv3.Warnings, error) getProcessesMutex sync.RWMutex - getProcessesArgsForCall []struct { - arg1 []ccv3.Query - } - getProcessesReturns struct { + getProcessesArgsForCall []FakeCloudControllerClientGetProcessesArgs + getProcessesReturns struct { result1 []resources.Process result2 ccv3.Warnings result3 error @@ -1464,10 +1278,8 @@ type FakeCloudControllerClient struct { } GetRolesStub func(...ccv3.Query) ([]resources.Role, ccv3.IncludedResources, ccv3.Warnings, error) getRolesMutex sync.RWMutex - getRolesArgsForCall []struct { - arg1 []ccv3.Query - } - getRolesReturns struct { + getRolesArgsForCall []FakeCloudControllerClientGetRolesArgs + getRolesReturns struct { result1 []resources.Role result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1481,9 +1293,8 @@ type FakeCloudControllerClient struct { } GetRootStub func() (ccv3.Root, ccv3.Warnings, error) getRootMutex sync.RWMutex - getRootArgsForCall []struct { - } - getRootReturns struct { + getRootArgsForCall []struct{} + getRootReturns struct { result1 ccv3.Root result2 ccv3.Warnings result3 error @@ -1495,10 +1306,8 @@ type FakeCloudControllerClient struct { } GetRouteBindingsStub func(...ccv3.Query) ([]resources.RouteBinding, ccv3.IncludedResources, ccv3.Warnings, error) getRouteBindingsMutex sync.RWMutex - getRouteBindingsArgsForCall []struct { - arg1 []ccv3.Query - } - getRouteBindingsReturns struct { + getRouteBindingsArgsForCall []FakeCloudControllerClientGetRouteBindingsArgs + getRouteBindingsReturns struct { result1 []resources.RouteBinding result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1512,10 +1321,8 @@ type FakeCloudControllerClient struct { } GetRouteDestinationsStub func(string) ([]resources.RouteDestination, ccv3.Warnings, error) getRouteDestinationsMutex sync.RWMutex - getRouteDestinationsArgsForCall []struct { - arg1 string - } - getRouteDestinationsReturns struct { + getRouteDestinationsArgsForCall []FakeCloudControllerClientGetRouteDestinationsArgs + getRouteDestinationsReturns struct { result1 []resources.RouteDestination result2 ccv3.Warnings result3 error @@ -1527,10 +1334,8 @@ type FakeCloudControllerClient struct { } GetRoutePoliciesStub func(...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error) getRoutePoliciesMutex sync.RWMutex - getRoutePoliciesArgsForCall []struct { - arg1 []ccv3.Query - } - getRoutePoliciesReturns struct { + getRoutePoliciesArgsForCall []FakeCloudControllerClientGetRoutePoliciesArgs + getRoutePoliciesReturns struct { result1 []resources.RoutePolicy result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1544,10 +1349,8 @@ type FakeCloudControllerClient struct { } GetRoutesStub func(...ccv3.Query) ([]resources.Route, ccv3.Warnings, error) getRoutesMutex sync.RWMutex - getRoutesArgsForCall []struct { - arg1 []ccv3.Query - } - getRoutesReturns struct { + getRoutesArgsForCall []FakeCloudControllerClientGetRoutesArgs + getRoutesReturns struct { result1 []resources.Route result2 ccv3.Warnings result3 error @@ -1559,11 +1362,8 @@ type FakeCloudControllerClient struct { } GetRunningSecurityGroupsStub func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) getRunningSecurityGroupsMutex sync.RWMutex - getRunningSecurityGroupsArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getRunningSecurityGroupsReturns struct { + getRunningSecurityGroupsArgsForCall []FakeCloudControllerClientGetRunningSecurityGroupsArgs + getRunningSecurityGroupsReturns struct { result1 []resources.SecurityGroup result2 ccv3.Warnings result3 error @@ -1575,10 +1375,8 @@ type FakeCloudControllerClient struct { } GetSSHEnabledStub func(string) (ccv3.SSHEnabled, ccv3.Warnings, error) getSSHEnabledMutex sync.RWMutex - getSSHEnabledArgsForCall []struct { - arg1 string - } - getSSHEnabledReturns struct { + getSSHEnabledArgsForCall []FakeCloudControllerClientGetSSHEnabledArgs + getSSHEnabledReturns struct { result1 ccv3.SSHEnabled result2 ccv3.Warnings result3 error @@ -1590,10 +1388,8 @@ type FakeCloudControllerClient struct { } GetSecurityGroupsStub func(...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) getSecurityGroupsMutex sync.RWMutex - getSecurityGroupsArgsForCall []struct { - arg1 []ccv3.Query - } - getSecurityGroupsReturns struct { + getSecurityGroupsArgsForCall []FakeCloudControllerClientGetSecurityGroupsArgs + getSecurityGroupsReturns struct { result1 []resources.SecurityGroup result2 ccv3.Warnings result3 error @@ -1603,12 +1399,36 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + GetServiceAccountStub func(string) (resources.ServiceAccount, ccv3.Warnings, error) + getServiceAccountMutex sync.RWMutex + getServiceAccountArgsForCall []FakeCloudControllerClientGetServiceAccountArgs + getServiceAccountReturns struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } + getServiceAccountReturnsOnCall map[int]struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } + GetServiceAccountsStub func(...ccv3.Query) ([]resources.ServiceAccount, ccv3.Warnings, error) + getServiceAccountsMutex sync.RWMutex + getServiceAccountsArgsForCall []FakeCloudControllerClientGetServiceAccountsArgs + getServiceAccountsReturns struct { + result1 []resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } + getServiceAccountsReturnsOnCall map[int]struct { + result1 []resources.ServiceAccount + result2 ccv3.Warnings + result3 error + } GetServiceBrokersStub func(...ccv3.Query) ([]resources.ServiceBroker, ccv3.Warnings, error) getServiceBrokersMutex sync.RWMutex - getServiceBrokersArgsForCall []struct { - arg1 []ccv3.Query - } - getServiceBrokersReturns struct { + getServiceBrokersArgsForCall []FakeCloudControllerClientGetServiceBrokersArgs + getServiceBrokersReturns struct { result1 []resources.ServiceBroker result2 ccv3.Warnings result3 error @@ -1620,10 +1440,8 @@ type FakeCloudControllerClient struct { } GetServiceCredentialBindingDetailsStub func(string) (resources.ServiceCredentialBindingDetails, ccv3.Warnings, error) getServiceCredentialBindingDetailsMutex sync.RWMutex - getServiceCredentialBindingDetailsArgsForCall []struct { - arg1 string - } - getServiceCredentialBindingDetailsReturns struct { + getServiceCredentialBindingDetailsArgsForCall []FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs + getServiceCredentialBindingDetailsReturns struct { result1 resources.ServiceCredentialBindingDetails result2 ccv3.Warnings result3 error @@ -1635,10 +1453,8 @@ type FakeCloudControllerClient struct { } GetServiceCredentialBindingsStub func(...ccv3.Query) ([]resources.ServiceCredentialBinding, ccv3.Warnings, error) getServiceCredentialBindingsMutex sync.RWMutex - getServiceCredentialBindingsArgsForCall []struct { - arg1 []ccv3.Query - } - getServiceCredentialBindingsReturns struct { + getServiceCredentialBindingsArgsForCall []FakeCloudControllerClientGetServiceCredentialBindingsArgs + getServiceCredentialBindingsReturns struct { result1 []resources.ServiceCredentialBinding result2 ccv3.Warnings result3 error @@ -1650,10 +1466,8 @@ type FakeCloudControllerClient struct { } GetServiceInstanceByGUIDStub func(string) (resources.ServiceInstance, ccv3.Warnings, error) getServiceInstanceByGUIDMutex sync.RWMutex - getServiceInstanceByGUIDArgsForCall []struct { - arg1 string - } - getServiceInstanceByGUIDReturns struct { + getServiceInstanceByGUIDArgsForCall []FakeCloudControllerClientGetServiceInstanceByGUIDArgs + getServiceInstanceByGUIDReturns struct { result1 resources.ServiceInstance result2 ccv3.Warnings result3 error @@ -1665,12 +1479,8 @@ type FakeCloudControllerClient struct { } GetServiceInstanceByNameAndSpaceStub func(string, string, ...ccv3.Query) (resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) getServiceInstanceByNameAndSpaceMutex sync.RWMutex - getServiceInstanceByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 []ccv3.Query - } - getServiceInstanceByNameAndSpaceReturns struct { + getServiceInstanceByNameAndSpaceArgsForCall []FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs + getServiceInstanceByNameAndSpaceReturns struct { result1 resources.ServiceInstance result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1684,10 +1494,8 @@ type FakeCloudControllerClient struct { } GetServiceInstanceParametersStub func(string) (types.JSONObject, ccv3.Warnings, error) getServiceInstanceParametersMutex sync.RWMutex - getServiceInstanceParametersArgsForCall []struct { - arg1 string - } - getServiceInstanceParametersReturns struct { + getServiceInstanceParametersArgsForCall []FakeCloudControllerClientGetServiceInstanceParametersArgs + getServiceInstanceParametersReturns struct { result1 types.JSONObject result2 ccv3.Warnings result3 error @@ -1699,10 +1507,8 @@ type FakeCloudControllerClient struct { } GetServiceInstanceSharedSpacesStub func(string) ([]ccv3.SpaceWithOrganization, ccv3.Warnings, error) getServiceInstanceSharedSpacesMutex sync.RWMutex - getServiceInstanceSharedSpacesArgsForCall []struct { - arg1 string - } - getServiceInstanceSharedSpacesReturns struct { + getServiceInstanceSharedSpacesArgsForCall []FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs + getServiceInstanceSharedSpacesReturns struct { result1 []ccv3.SpaceWithOrganization result2 ccv3.Warnings result3 error @@ -1714,10 +1520,8 @@ type FakeCloudControllerClient struct { } GetServiceInstanceUsageSummaryStub func(string) ([]resources.ServiceInstanceUsageSummary, ccv3.Warnings, error) getServiceInstanceUsageSummaryMutex sync.RWMutex - getServiceInstanceUsageSummaryArgsForCall []struct { - arg1 string - } - getServiceInstanceUsageSummaryReturns struct { + getServiceInstanceUsageSummaryArgsForCall []FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs + getServiceInstanceUsageSummaryReturns struct { result1 []resources.ServiceInstanceUsageSummary result2 ccv3.Warnings result3 error @@ -1729,10 +1533,8 @@ type FakeCloudControllerClient struct { } GetServiceInstancesStub func(...ccv3.Query) ([]resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) getServiceInstancesMutex sync.RWMutex - getServiceInstancesArgsForCall []struct { - arg1 []ccv3.Query - } - getServiceInstancesReturns struct { + getServiceInstancesArgsForCall []FakeCloudControllerClientGetServiceInstancesArgs + getServiceInstancesReturns struct { result1 []resources.ServiceInstance result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1746,10 +1548,8 @@ type FakeCloudControllerClient struct { } GetServiceOfferingByGUIDStub func(string) (resources.ServiceOffering, ccv3.Warnings, error) getServiceOfferingByGUIDMutex sync.RWMutex - getServiceOfferingByGUIDArgsForCall []struct { - arg1 string - } - getServiceOfferingByGUIDReturns struct { + getServiceOfferingByGUIDArgsForCall []FakeCloudControllerClientGetServiceOfferingByGUIDArgs + getServiceOfferingByGUIDReturns struct { result1 resources.ServiceOffering result2 ccv3.Warnings result3 error @@ -1761,11 +1561,8 @@ type FakeCloudControllerClient struct { } GetServiceOfferingByNameAndBrokerStub func(string, string) (resources.ServiceOffering, ccv3.Warnings, error) getServiceOfferingByNameAndBrokerMutex sync.RWMutex - getServiceOfferingByNameAndBrokerArgsForCall []struct { - arg1 string - arg2 string - } - getServiceOfferingByNameAndBrokerReturns struct { + getServiceOfferingByNameAndBrokerArgsForCall []FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs + getServiceOfferingByNameAndBrokerReturns struct { result1 resources.ServiceOffering result2 ccv3.Warnings result3 error @@ -1777,10 +1574,8 @@ type FakeCloudControllerClient struct { } GetServiceOfferingsStub func(...ccv3.Query) ([]resources.ServiceOffering, ccv3.Warnings, error) getServiceOfferingsMutex sync.RWMutex - getServiceOfferingsArgsForCall []struct { - arg1 []ccv3.Query - } - getServiceOfferingsReturns struct { + getServiceOfferingsArgsForCall []FakeCloudControllerClientGetServiceOfferingsArgs + getServiceOfferingsReturns struct { result1 []resources.ServiceOffering result2 ccv3.Warnings result3 error @@ -1792,10 +1587,8 @@ type FakeCloudControllerClient struct { } GetServicePlanByGUIDStub func(string) (resources.ServicePlan, ccv3.Warnings, error) getServicePlanByGUIDMutex sync.RWMutex - getServicePlanByGUIDArgsForCall []struct { - arg1 string - } - getServicePlanByGUIDReturns struct { + getServicePlanByGUIDArgsForCall []FakeCloudControllerClientGetServicePlanByGUIDArgs + getServicePlanByGUIDReturns struct { result1 resources.ServicePlan result2 ccv3.Warnings result3 error @@ -1807,10 +1600,8 @@ type FakeCloudControllerClient struct { } GetServicePlanVisibilityStub func(string) (resources.ServicePlanVisibility, ccv3.Warnings, error) getServicePlanVisibilityMutex sync.RWMutex - getServicePlanVisibilityArgsForCall []struct { - arg1 string - } - getServicePlanVisibilityReturns struct { + getServicePlanVisibilityArgsForCall []FakeCloudControllerClientGetServicePlanVisibilityArgs + getServicePlanVisibilityReturns struct { result1 resources.ServicePlanVisibility result2 ccv3.Warnings result3 error @@ -1822,10 +1613,8 @@ type FakeCloudControllerClient struct { } GetServicePlansStub func(...ccv3.Query) ([]resources.ServicePlan, ccv3.Warnings, error) getServicePlansMutex sync.RWMutex - getServicePlansArgsForCall []struct { - arg1 []ccv3.Query - } - getServicePlansReturns struct { + getServicePlansArgsForCall []FakeCloudControllerClientGetServicePlansArgs + getServicePlansReturns struct { result1 []resources.ServicePlan result2 ccv3.Warnings result3 error @@ -1837,10 +1626,8 @@ type FakeCloudControllerClient struct { } GetServicePlansWithOfferingsStub func(...ccv3.Query) ([]ccv3.ServiceOfferingWithPlans, ccv3.Warnings, error) getServicePlansWithOfferingsMutex sync.RWMutex - getServicePlansWithOfferingsArgsForCall []struct { - arg1 []ccv3.Query - } - getServicePlansWithOfferingsReturns struct { + getServicePlansWithOfferingsArgsForCall []FakeCloudControllerClientGetServicePlansWithOfferingsArgs + getServicePlansWithOfferingsReturns struct { result1 []ccv3.ServiceOfferingWithPlans result2 ccv3.Warnings result3 error @@ -1852,10 +1639,8 @@ type FakeCloudControllerClient struct { } GetServicePlansWithSpaceAndOrganizationStub func(...ccv3.Query) ([]ccv3.ServicePlanWithSpaceAndOrganization, ccv3.Warnings, error) getServicePlansWithSpaceAndOrganizationMutex sync.RWMutex - getServicePlansWithSpaceAndOrganizationArgsForCall []struct { - arg1 []ccv3.Query - } - getServicePlansWithSpaceAndOrganizationReturns struct { + getServicePlansWithSpaceAndOrganizationArgsForCall []FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs + getServicePlansWithSpaceAndOrganizationReturns struct { result1 []ccv3.ServicePlanWithSpaceAndOrganization result2 ccv3.Warnings result3 error @@ -1867,11 +1652,8 @@ type FakeCloudControllerClient struct { } GetSpaceFeatureStub func(string, string) (bool, ccv3.Warnings, error) getSpaceFeatureMutex sync.RWMutex - getSpaceFeatureArgsForCall []struct { - arg1 string - arg2 string - } - getSpaceFeatureReturns struct { + getSpaceFeatureArgsForCall []FakeCloudControllerClientGetSpaceFeatureArgs + getSpaceFeatureReturns struct { result1 bool result2 ccv3.Warnings result3 error @@ -1883,10 +1665,8 @@ type FakeCloudControllerClient struct { } GetSpaceIsolationSegmentStub func(string) (resources.Relationship, ccv3.Warnings, error) getSpaceIsolationSegmentMutex sync.RWMutex - getSpaceIsolationSegmentArgsForCall []struct { - arg1 string - } - getSpaceIsolationSegmentReturns struct { + getSpaceIsolationSegmentArgsForCall []FakeCloudControllerClientGetSpaceIsolationSegmentArgs + getSpaceIsolationSegmentReturns struct { result1 resources.Relationship result2 ccv3.Warnings result3 error @@ -1898,11 +1678,8 @@ type FakeCloudControllerClient struct { } GetSpaceManifestDiffStub func(string, []byte) (resources.ManifestDiff, ccv3.Warnings, error) getSpaceManifestDiffMutex sync.RWMutex - getSpaceManifestDiffArgsForCall []struct { - arg1 string - arg2 []byte - } - getSpaceManifestDiffReturns struct { + getSpaceManifestDiffArgsForCall []FakeCloudControllerClientGetSpaceManifestDiffArgs + getSpaceManifestDiffReturns struct { result1 resources.ManifestDiff result2 ccv3.Warnings result3 error @@ -1914,10 +1691,8 @@ type FakeCloudControllerClient struct { } GetSpaceQuotaStub func(string) (resources.SpaceQuota, ccv3.Warnings, error) getSpaceQuotaMutex sync.RWMutex - getSpaceQuotaArgsForCall []struct { - arg1 string - } - getSpaceQuotaReturns struct { + getSpaceQuotaArgsForCall []FakeCloudControllerClientGetSpaceQuotaArgs + getSpaceQuotaReturns struct { result1 resources.SpaceQuota result2 ccv3.Warnings result3 error @@ -1929,10 +1704,8 @@ type FakeCloudControllerClient struct { } GetSpaceQuotasStub func(...ccv3.Query) ([]resources.SpaceQuota, ccv3.Warnings, error) getSpaceQuotasMutex sync.RWMutex - getSpaceQuotasArgsForCall []struct { - arg1 []ccv3.Query - } - getSpaceQuotasReturns struct { + getSpaceQuotasArgsForCall []FakeCloudControllerClientGetSpaceQuotasArgs + getSpaceQuotasReturns struct { result1 []resources.SpaceQuota result2 ccv3.Warnings result3 error @@ -1944,10 +1717,8 @@ type FakeCloudControllerClient struct { } GetSpacesStub func(...ccv3.Query) ([]resources.Space, ccv3.IncludedResources, ccv3.Warnings, error) getSpacesMutex sync.RWMutex - getSpacesArgsForCall []struct { - arg1 []ccv3.Query - } - getSpacesReturns struct { + getSpacesArgsForCall []FakeCloudControllerClientGetSpacesArgs + getSpacesReturns struct { result1 []resources.Space result2 ccv3.IncludedResources result3 ccv3.Warnings @@ -1961,10 +1732,8 @@ type FakeCloudControllerClient struct { } GetStacksStub func(...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error) getStacksMutex sync.RWMutex - getStacksArgsForCall []struct { - arg1 []ccv3.Query - } - getStacksReturns struct { + getStacksArgsForCall []FakeCloudControllerClientGetStacksArgs + getStacksReturns struct { result1 []resources.Stack result2 ccv3.Warnings result3 error @@ -1976,11 +1745,8 @@ type FakeCloudControllerClient struct { } GetStagingSecurityGroupsStub func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) getStagingSecurityGroupsMutex sync.RWMutex - getStagingSecurityGroupsArgsForCall []struct { - arg1 string - arg2 []ccv3.Query - } - getStagingSecurityGroupsReturns struct { + getStagingSecurityGroupsArgsForCall []FakeCloudControllerClientGetStagingSecurityGroupsArgs + getStagingSecurityGroupsReturns struct { result1 []resources.SecurityGroup result2 ccv3.Warnings result3 error @@ -1992,10 +1758,8 @@ type FakeCloudControllerClient struct { } GetTaskStub func(string) (resources.Task, ccv3.Warnings, error) getTaskMutex sync.RWMutex - getTaskArgsForCall []struct { - arg1 string - } - getTaskReturns struct { + getTaskArgsForCall []FakeCloudControllerClientGetTaskArgs + getTaskReturns struct { result1 resources.Task result2 ccv3.Warnings result3 error @@ -2007,10 +1771,8 @@ type FakeCloudControllerClient struct { } GetUserStub func(string) (resources.User, ccv3.Warnings, error) getUserMutex sync.RWMutex - getUserArgsForCall []struct { - arg1 string - } - getUserReturns struct { + getUserArgsForCall []FakeCloudControllerClientGetUserArgs + getUserReturns struct { result1 resources.User result2 ccv3.Warnings result3 error @@ -2022,10 +1784,8 @@ type FakeCloudControllerClient struct { } GetUsersStub func(...ccv3.Query) ([]resources.User, ccv3.Warnings, error) getUsersMutex sync.RWMutex - getUsersArgsForCall []struct { - arg1 []ccv3.Query - } - getUsersReturns struct { + getUsersArgsForCall []FakeCloudControllerClientGetUsersArgs + getUsersReturns struct { result1 []resources.User result2 ccv3.Warnings result3 error @@ -2037,13 +1797,8 @@ type FakeCloudControllerClient struct { } MakeRequestSendReceiveRawStub func(string, string, http.Header, []byte) ([]byte, *http.Response, error) makeRequestSendReceiveRawMutex sync.RWMutex - makeRequestSendReceiveRawArgsForCall []struct { - arg1 string - arg2 string - arg3 http.Header - arg4 []byte - } - makeRequestSendReceiveRawReturns struct { + makeRequestSendReceiveRawArgsForCall []FakeCloudControllerClientMakeRequestSendReceiveRawArgs + makeRequestSendReceiveRawReturns struct { result1 []byte result2 *http.Response result3 error @@ -2055,13 +1810,8 @@ type FakeCloudControllerClient struct { } MapRouteStub func(string, string, string, int) (ccv3.Warnings, error) mapRouteMutex sync.RWMutex - mapRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - mapRouteReturns struct { + mapRouteArgsForCall []FakeCloudControllerClientMapRouteArgs + mapRouteReturns struct { result1 ccv3.Warnings result2 error } @@ -2071,11 +1821,8 @@ type FakeCloudControllerClient struct { } MoveRouteStub func(string, string) (ccv3.Warnings, error) moveRouteMutex sync.RWMutex - moveRouteArgsForCall []struct { - arg1 string - arg2 string - } - moveRouteReturns struct { + moveRouteArgsForCall []FakeCloudControllerClientMoveRouteArgs + moveRouteReturns struct { result1 ccv3.Warnings result2 error } @@ -2085,10 +1832,8 @@ type FakeCloudControllerClient struct { } PollJobStub func(ccv3.JobURL) (ccv3.Warnings, error) pollJobMutex sync.RWMutex - pollJobArgsForCall []struct { - arg1 ccv3.JobURL - } - pollJobReturns struct { + pollJobArgsForCall []FakeCloudControllerClientPollJobArgs + pollJobReturns struct { result1 ccv3.Warnings result2 error } @@ -2098,11 +1843,8 @@ type FakeCloudControllerClient struct { } PollJobForStateStub func(ccv3.JobURL, constant.JobState) (ccv3.Warnings, error) pollJobForStateMutex sync.RWMutex - pollJobForStateArgsForCall []struct { - arg1 ccv3.JobURL - arg2 constant.JobState - } - pollJobForStateReturns struct { + pollJobForStateArgsForCall []FakeCloudControllerClientPollJobForStateArgs + pollJobForStateReturns struct { result1 ccv3.Warnings result2 error } @@ -2112,10 +1854,8 @@ type FakeCloudControllerClient struct { } PollJobToEventStreamStub func(ccv3.JobURL) chan ccv3.PollJobEvent pollJobToEventStreamMutex sync.RWMutex - pollJobToEventStreamArgsForCall []struct { - arg1 ccv3.JobURL - } - pollJobToEventStreamReturns struct { + pollJobToEventStreamArgsForCall []FakeCloudControllerClientPollJobToEventStreamArgs + pollJobToEventStreamReturns struct { result1 chan ccv3.PollJobEvent } pollJobToEventStreamReturnsOnCall map[int]struct { @@ -2123,10 +1863,8 @@ type FakeCloudControllerClient struct { } PurgeServiceOfferingStub func(string) (ccv3.Warnings, error) purgeServiceOfferingMutex sync.RWMutex - purgeServiceOfferingArgsForCall []struct { - arg1 string - } - purgeServiceOfferingReturns struct { + purgeServiceOfferingArgsForCall []FakeCloudControllerClientPurgeServiceOfferingArgs + purgeServiceOfferingReturns struct { result1 ccv3.Warnings result2 error } @@ -2136,10 +1874,8 @@ type FakeCloudControllerClient struct { } ResourceMatchStub func([]ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error) resourceMatchMutex sync.RWMutex - resourceMatchArgsForCall []struct { - arg1 []ccv3.Resource - } - resourceMatchReturns struct { + resourceMatchArgsForCall []FakeCloudControllerClientResourceMatchArgs + resourceMatchReturns struct { result1 []ccv3.Resource result2 ccv3.Warnings result3 error @@ -2151,9 +1887,8 @@ type FakeCloudControllerClient struct { } RootResponseStub func() (ccv3.Root, ccv3.Warnings, error) rootResponseMutex sync.RWMutex - rootResponseArgsForCall []struct { - } - rootResponseReturns struct { + rootResponseArgsForCall []struct{} + rootResponseReturns struct { result1 ccv3.Root result2 ccv3.Warnings result3 error @@ -2165,11 +1900,8 @@ type FakeCloudControllerClient struct { } SetApplicationDropletStub func(string, string) (resources.Relationship, ccv3.Warnings, error) setApplicationDropletMutex sync.RWMutex - setApplicationDropletArgsForCall []struct { - arg1 string - arg2 string - } - setApplicationDropletReturns struct { + setApplicationDropletArgsForCall []FakeCloudControllerClientSetApplicationDropletArgs + setApplicationDropletReturns struct { result1 resources.Relationship result2 ccv3.Warnings result3 error @@ -2181,11 +1913,8 @@ type FakeCloudControllerClient struct { } SharePrivateDomainToOrgsStub func(string, ccv3.SharedOrgs) (ccv3.Warnings, error) sharePrivateDomainToOrgsMutex sync.RWMutex - sharePrivateDomainToOrgsArgsForCall []struct { - arg1 string - arg2 ccv3.SharedOrgs - } - sharePrivateDomainToOrgsReturns struct { + sharePrivateDomainToOrgsArgsForCall []FakeCloudControllerClientSharePrivateDomainToOrgsArgs + sharePrivateDomainToOrgsReturns struct { result1 ccv3.Warnings result2 error } @@ -2195,11 +1924,8 @@ type FakeCloudControllerClient struct { } ShareRouteStub func(string, string) (ccv3.Warnings, error) shareRouteMutex sync.RWMutex - shareRouteArgsForCall []struct { - arg1 string - arg2 string - } - shareRouteReturns struct { + shareRouteArgsForCall []FakeCloudControllerClientShareRouteArgs + shareRouteReturns struct { result1 ccv3.Warnings result2 error } @@ -2209,11 +1935,8 @@ type FakeCloudControllerClient struct { } ShareServiceInstanceToSpacesStub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error) shareServiceInstanceToSpacesMutex sync.RWMutex - shareServiceInstanceToSpacesArgsForCall []struct { - arg1 string - arg2 []string - } - shareServiceInstanceToSpacesReturns struct { + shareServiceInstanceToSpacesArgsForCall []FakeCloudControllerClientShareServiceInstanceToSpacesArgs + shareServiceInstanceToSpacesReturns struct { result1 resources.RelationshipList result2 ccv3.Warnings result3 error @@ -2223,18 +1946,13 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } - TargetCFStub func(ccv3.TargetSettings) - targetCFMutex sync.RWMutex - targetCFArgsForCall []struct { - arg1 ccv3.TargetSettings - } + TargetCFStub func(ccv3.TargetSettings) + targetCFMutex sync.RWMutex + targetCFArgsForCall []FakeCloudControllerClientTargetCFArgs UnbindSecurityGroupRunningSpaceStub func(string, string) (ccv3.Warnings, error) unbindSecurityGroupRunningSpaceMutex sync.RWMutex - unbindSecurityGroupRunningSpaceArgsForCall []struct { - arg1 string - arg2 string - } - unbindSecurityGroupRunningSpaceReturns struct { + unbindSecurityGroupRunningSpaceArgsForCall []FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs + unbindSecurityGroupRunningSpaceReturns struct { result1 ccv3.Warnings result2 error } @@ -2244,11 +1962,8 @@ type FakeCloudControllerClient struct { } UnbindSecurityGroupStagingSpaceStub func(string, string) (ccv3.Warnings, error) unbindSecurityGroupStagingSpaceMutex sync.RWMutex - unbindSecurityGroupStagingSpaceArgsForCall []struct { - arg1 string - arg2 string - } - unbindSecurityGroupStagingSpaceReturns struct { + unbindSecurityGroupStagingSpaceArgsForCall []FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs + unbindSecurityGroupStagingSpaceReturns struct { result1 ccv3.Warnings result2 error } @@ -2258,11 +1973,8 @@ type FakeCloudControllerClient struct { } UnmapRouteStub func(string, string) (ccv3.Warnings, error) unmapRouteMutex sync.RWMutex - unmapRouteArgsForCall []struct { - arg1 string - arg2 string - } - unmapRouteReturns struct { + unmapRouteArgsForCall []FakeCloudControllerClientUnmapRouteArgs + unmapRouteReturns struct { result1 ccv3.Warnings result2 error } @@ -2272,11 +1984,8 @@ type FakeCloudControllerClient struct { } UnsetSpaceQuotaStub func(string, string) (ccv3.Warnings, error) unsetSpaceQuotaMutex sync.RWMutex - unsetSpaceQuotaArgsForCall []struct { - arg1 string - arg2 string - } - unsetSpaceQuotaReturns struct { + unsetSpaceQuotaArgsForCall []FakeCloudControllerClientUnsetSpaceQuotaArgs + unsetSpaceQuotaReturns struct { result1 ccv3.Warnings result2 error } @@ -2286,11 +1995,8 @@ type FakeCloudControllerClient struct { } UnsharePrivateDomainFromOrgStub func(string, string) (ccv3.Warnings, error) unsharePrivateDomainFromOrgMutex sync.RWMutex - unsharePrivateDomainFromOrgArgsForCall []struct { - arg1 string - arg2 string - } - unsharePrivateDomainFromOrgReturns struct { + unsharePrivateDomainFromOrgArgsForCall []FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs + unsharePrivateDomainFromOrgReturns struct { result1 ccv3.Warnings result2 error } @@ -2300,11 +2006,8 @@ type FakeCloudControllerClient struct { } UnshareRouteStub func(string, string) (ccv3.Warnings, error) unshareRouteMutex sync.RWMutex - unshareRouteArgsForCall []struct { - arg1 string - arg2 string - } - unshareRouteReturns struct { + unshareRouteArgsForCall []FakeCloudControllerClientUnshareRouteArgs + unshareRouteReturns struct { result1 ccv3.Warnings result2 error } @@ -2314,11 +2017,8 @@ type FakeCloudControllerClient struct { } UnshareServiceInstanceFromSpaceStub func(string, string) (ccv3.Warnings, error) unshareServiceInstanceFromSpaceMutex sync.RWMutex - unshareServiceInstanceFromSpaceArgsForCall []struct { - arg1 string - arg2 string - } - unshareServiceInstanceFromSpaceReturns struct { + unshareServiceInstanceFromSpaceArgsForCall []FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs + unshareServiceInstanceFromSpaceReturns struct { result1 ccv3.Warnings result2 error } @@ -2328,12 +2028,8 @@ type FakeCloudControllerClient struct { } UpdateAppFeatureStub func(string, bool, string) (ccv3.Warnings, error) updateAppFeatureMutex sync.RWMutex - updateAppFeatureArgsForCall []struct { - arg1 string - arg2 bool - arg3 string - } - updateAppFeatureReturns struct { + updateAppFeatureArgsForCall []FakeCloudControllerClientUpdateAppFeatureArgs + updateAppFeatureReturns struct { result1 ccv3.Warnings result2 error } @@ -2343,10 +2039,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationStub func(resources.Application) (resources.Application, ccv3.Warnings, error) updateApplicationMutex sync.RWMutex - updateApplicationArgsForCall []struct { - arg1 resources.Application - } - updateApplicationReturns struct { + updateApplicationArgsForCall []FakeCloudControllerClientUpdateApplicationArgs + updateApplicationReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -2358,11 +2052,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationApplyManifestStub func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error) updateApplicationApplyManifestMutex sync.RWMutex - updateApplicationApplyManifestArgsForCall []struct { - arg1 string - arg2 []byte - } - updateApplicationApplyManifestReturns struct { + updateApplicationApplyManifestArgsForCall []FakeCloudControllerClientUpdateApplicationApplyManifestArgs + updateApplicationApplyManifestReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2374,11 +2065,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationEnvironmentVariablesStub func(string, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) updateApplicationEnvironmentVariablesMutex sync.RWMutex - updateApplicationEnvironmentVariablesArgsForCall []struct { - arg1 string - arg2 resources.EnvironmentVariables - } - updateApplicationEnvironmentVariablesReturns struct { + updateApplicationEnvironmentVariablesArgsForCall []FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs + updateApplicationEnvironmentVariablesReturns struct { result1 resources.EnvironmentVariables result2 ccv3.Warnings result3 error @@ -2390,11 +2078,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationNameStub func(string, string) (resources.Application, ccv3.Warnings, error) updateApplicationNameMutex sync.RWMutex - updateApplicationNameArgsForCall []struct { - arg1 string - arg2 string - } - updateApplicationNameReturns struct { + updateApplicationNameArgsForCall []FakeCloudControllerClientUpdateApplicationNameArgs + updateApplicationNameReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -2406,10 +2091,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationRestartStub func(string) (resources.Application, ccv3.Warnings, error) updateApplicationRestartMutex sync.RWMutex - updateApplicationRestartArgsForCall []struct { - arg1 string - } - updateApplicationRestartReturns struct { + updateApplicationRestartArgsForCall []FakeCloudControllerClientUpdateApplicationRestartArgs + updateApplicationRestartReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -2419,12 +2102,23 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + UpdateApplicationServiceAccountStub func(string, resources.Relationship) (ccv3.JobURL, ccv3.Warnings, error) + updateApplicationServiceAccountMutex sync.RWMutex + updateApplicationServiceAccountArgsForCall []FakeCloudControllerClientUpdateApplicationServiceAccountArgs + updateApplicationServiceAccountReturns struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } + updateApplicationServiceAccountReturnsOnCall map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } UpdateApplicationStartStub func(string) (resources.Application, ccv3.Warnings, error) updateApplicationStartMutex sync.RWMutex - updateApplicationStartArgsForCall []struct { - arg1 string - } - updateApplicationStartReturns struct { + updateApplicationStartArgsForCall []FakeCloudControllerClientUpdateApplicationStartArgs + updateApplicationStartReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -2436,10 +2130,8 @@ type FakeCloudControllerClient struct { } UpdateApplicationStopStub func(string) (resources.Application, ccv3.Warnings, error) updateApplicationStopMutex sync.RWMutex - updateApplicationStopArgsForCall []struct { - arg1 string - } - updateApplicationStopReturns struct { + updateApplicationStopArgsForCall []FakeCloudControllerClientUpdateApplicationStopArgs + updateApplicationStopReturns struct { result1 resources.Application result2 ccv3.Warnings result3 error @@ -2451,10 +2143,8 @@ type FakeCloudControllerClient struct { } UpdateBuildpackStub func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) updateBuildpackMutex sync.RWMutex - updateBuildpackArgsForCall []struct { - arg1 resources.Buildpack - } - updateBuildpackReturns struct { + updateBuildpackArgsForCall []FakeCloudControllerClientUpdateBuildpackArgs + updateBuildpackReturns struct { result1 resources.Buildpack result2 ccv3.Warnings result3 error @@ -2466,12 +2156,8 @@ type FakeCloudControllerClient struct { } UpdateDestinationStub func(string, string, string) (ccv3.Warnings, error) updateDestinationMutex sync.RWMutex - updateDestinationArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - updateDestinationReturns struct { + updateDestinationArgsForCall []FakeCloudControllerClientUpdateDestinationArgs + updateDestinationReturns struct { result1 ccv3.Warnings result2 error } @@ -2481,11 +2167,8 @@ type FakeCloudControllerClient struct { } UpdateEnvironmentVariableGroupStub func(constant.EnvironmentVariableGroupName, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) updateEnvironmentVariableGroupMutex sync.RWMutex - updateEnvironmentVariableGroupArgsForCall []struct { - arg1 constant.EnvironmentVariableGroupName - arg2 resources.EnvironmentVariables - } - updateEnvironmentVariableGroupReturns struct { + updateEnvironmentVariableGroupArgsForCall []FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs + updateEnvironmentVariableGroupReturns struct { result1 resources.EnvironmentVariables result2 ccv3.Warnings result3 error @@ -2497,10 +2180,8 @@ type FakeCloudControllerClient struct { } UpdateFeatureFlagStub func(resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error) updateFeatureFlagMutex sync.RWMutex - updateFeatureFlagArgsForCall []struct { - arg1 resources.FeatureFlag - } - updateFeatureFlagReturns struct { + updateFeatureFlagArgsForCall []FakeCloudControllerClientUpdateFeatureFlagArgs + updateFeatureFlagReturns struct { result1 resources.FeatureFlag result2 ccv3.Warnings result3 error @@ -2512,10 +2193,8 @@ type FakeCloudControllerClient struct { } UpdateOrganizationStub func(resources.Organization) (resources.Organization, ccv3.Warnings, error) updateOrganizationMutex sync.RWMutex - updateOrganizationArgsForCall []struct { - arg1 resources.Organization - } - updateOrganizationReturns struct { + updateOrganizationArgsForCall []FakeCloudControllerClientUpdateOrganizationArgs + updateOrganizationReturns struct { result1 resources.Organization result2 ccv3.Warnings result3 error @@ -2527,11 +2206,8 @@ type FakeCloudControllerClient struct { } UpdateOrganizationDefaultIsolationSegmentRelationshipStub func(string, string) (resources.Relationship, ccv3.Warnings, error) updateOrganizationDefaultIsolationSegmentRelationshipMutex sync.RWMutex - updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall []struct { - arg1 string - arg2 string - } - updateOrganizationDefaultIsolationSegmentRelationshipReturns struct { + updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall []FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs + updateOrganizationDefaultIsolationSegmentRelationshipReturns struct { result1 resources.Relationship result2 ccv3.Warnings result3 error @@ -2543,10 +2219,8 @@ type FakeCloudControllerClient struct { } UpdateOrganizationQuotaStub func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) updateOrganizationQuotaMutex sync.RWMutex - updateOrganizationQuotaArgsForCall []struct { - arg1 resources.OrganizationQuota - } - updateOrganizationQuotaReturns struct { + updateOrganizationQuotaArgsForCall []FakeCloudControllerClientUpdateOrganizationQuotaArgs + updateOrganizationQuotaReturns struct { result1 resources.OrganizationQuota result2 ccv3.Warnings result3 error @@ -2558,10 +2232,8 @@ type FakeCloudControllerClient struct { } UpdateProcessStub func(resources.Process) (resources.Process, ccv3.Warnings, error) updateProcessMutex sync.RWMutex - updateProcessArgsForCall []struct { - arg1 resources.Process - } - updateProcessReturns struct { + updateProcessArgsForCall []FakeCloudControllerClientUpdateProcessArgs + updateProcessReturns struct { result1 resources.Process result2 ccv3.Warnings result3 error @@ -2573,12 +2245,8 @@ type FakeCloudControllerClient struct { } UpdateResourceMetadataStub func(string, string, resources.Metadata) (ccv3.JobURL, ccv3.Warnings, error) updateResourceMetadataMutex sync.RWMutex - updateResourceMetadataArgsForCall []struct { - arg1 string - arg2 string - arg3 resources.Metadata - } - updateResourceMetadataReturns struct { + updateResourceMetadataArgsForCall []FakeCloudControllerClientUpdateResourceMetadataArgs + updateResourceMetadataReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2590,11 +2258,8 @@ type FakeCloudControllerClient struct { } UpdateRouteStub func(string, map[string]*string) (resources.Route, ccv3.Warnings, error) updateRouteMutex sync.RWMutex - updateRouteArgsForCall []struct { - arg1 string - arg2 map[string]*string - } - updateRouteReturns struct { + updateRouteArgsForCall []FakeCloudControllerClientUpdateRouteArgs + updateRouteReturns struct { result1 resources.Route result2 ccv3.Warnings result3 error @@ -2606,10 +2271,8 @@ type FakeCloudControllerClient struct { } UpdateSecurityGroupStub func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) updateSecurityGroupMutex sync.RWMutex - updateSecurityGroupArgsForCall []struct { - arg1 resources.SecurityGroup - } - updateSecurityGroupReturns struct { + updateSecurityGroupArgsForCall []FakeCloudControllerClientUpdateSecurityGroupArgs + updateSecurityGroupReturns struct { result1 resources.SecurityGroup result2 ccv3.Warnings result3 error @@ -2621,11 +2284,8 @@ type FakeCloudControllerClient struct { } UpdateSecurityGroupRunningSpaceStub func(string, []string) (ccv3.Warnings, error) updateSecurityGroupRunningSpaceMutex sync.RWMutex - updateSecurityGroupRunningSpaceArgsForCall []struct { - arg1 string - arg2 []string - } - updateSecurityGroupRunningSpaceReturns struct { + updateSecurityGroupRunningSpaceArgsForCall []FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs + updateSecurityGroupRunningSpaceReturns struct { result1 ccv3.Warnings result2 error } @@ -2635,11 +2295,8 @@ type FakeCloudControllerClient struct { } UpdateSecurityGroupStagingSpaceStub func(string, []string) (ccv3.Warnings, error) updateSecurityGroupStagingSpaceMutex sync.RWMutex - updateSecurityGroupStagingSpaceArgsForCall []struct { - arg1 string - arg2 []string - } - updateSecurityGroupStagingSpaceReturns struct { + updateSecurityGroupStagingSpaceArgsForCall []FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs + updateSecurityGroupStagingSpaceReturns struct { result1 ccv3.Warnings result2 error } @@ -2647,13 +2304,23 @@ type FakeCloudControllerClient struct { result1 ccv3.Warnings result2 error } + UpdateServiceAccountEnabledStub func(string, bool) (ccv3.JobURL, ccv3.Warnings, error) + updateServiceAccountEnabledMutex sync.RWMutex + updateServiceAccountEnabledArgsForCall []FakeCloudControllerClientUpdateServiceAccountEnabledArgs + updateServiceAccountEnabledReturns struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } + updateServiceAccountEnabledReturnsOnCall map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } UpdateServiceBrokerStub func(string, resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) updateServiceBrokerMutex sync.RWMutex - updateServiceBrokerArgsForCall []struct { - arg1 string - arg2 resources.ServiceBroker - } - updateServiceBrokerReturns struct { + updateServiceBrokerArgsForCall []FakeCloudControllerClientUpdateServiceBrokerArgs + updateServiceBrokerReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2665,11 +2332,8 @@ type FakeCloudControllerClient struct { } UpdateServiceInstanceStub func(string, resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) updateServiceInstanceMutex sync.RWMutex - updateServiceInstanceArgsForCall []struct { - arg1 string - arg2 resources.ServiceInstance - } - updateServiceInstanceReturns struct { + updateServiceInstanceArgsForCall []FakeCloudControllerClientUpdateServiceInstanceArgs + updateServiceInstanceReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2681,11 +2345,8 @@ type FakeCloudControllerClient struct { } UpdateServicePlanVisibilityStub func(string, resources.ServicePlanVisibility) (resources.ServicePlanVisibility, ccv3.Warnings, error) updateServicePlanVisibilityMutex sync.RWMutex - updateServicePlanVisibilityArgsForCall []struct { - arg1 string - arg2 resources.ServicePlanVisibility - } - updateServicePlanVisibilityReturns struct { + updateServicePlanVisibilityArgsForCall []FakeCloudControllerClientUpdateServicePlanVisibilityArgs + updateServicePlanVisibilityReturns struct { result1 resources.ServicePlanVisibility result2 ccv3.Warnings result3 error @@ -2697,10 +2358,8 @@ type FakeCloudControllerClient struct { } UpdateSpaceStub func(resources.Space) (resources.Space, ccv3.Warnings, error) updateSpaceMutex sync.RWMutex - updateSpaceArgsForCall []struct { - arg1 resources.Space - } - updateSpaceReturns struct { + updateSpaceArgsForCall []FakeCloudControllerClientUpdateSpaceArgs + updateSpaceReturns struct { result1 resources.Space result2 ccv3.Warnings result3 error @@ -2712,11 +2371,8 @@ type FakeCloudControllerClient struct { } UpdateSpaceApplyManifestStub func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error) updateSpaceApplyManifestMutex sync.RWMutex - updateSpaceApplyManifestArgsForCall []struct { - arg1 string - arg2 []byte - } - updateSpaceApplyManifestReturns struct { + updateSpaceApplyManifestArgsForCall []FakeCloudControllerClientUpdateSpaceApplyManifestArgs + updateSpaceApplyManifestReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2728,12 +2384,8 @@ type FakeCloudControllerClient struct { } UpdateSpaceFeatureStub func(string, bool, string) (ccv3.Warnings, error) updateSpaceFeatureMutex sync.RWMutex - updateSpaceFeatureArgsForCall []struct { - arg1 string - arg2 bool - arg3 string - } - updateSpaceFeatureReturns struct { + updateSpaceFeatureArgsForCall []FakeCloudControllerClientUpdateSpaceFeatureArgs + updateSpaceFeatureReturns struct { result1 ccv3.Warnings result2 error } @@ -2743,11 +2395,8 @@ type FakeCloudControllerClient struct { } UpdateSpaceIsolationSegmentRelationshipStub func(string, string) (resources.Relationship, ccv3.Warnings, error) updateSpaceIsolationSegmentRelationshipMutex sync.RWMutex - updateSpaceIsolationSegmentRelationshipArgsForCall []struct { - arg1 string - arg2 string - } - updateSpaceIsolationSegmentRelationshipReturns struct { + updateSpaceIsolationSegmentRelationshipArgsForCall []FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs + updateSpaceIsolationSegmentRelationshipReturns struct { result1 resources.Relationship result2 ccv3.Warnings result3 error @@ -2759,10 +2408,8 @@ type FakeCloudControllerClient struct { } UpdateSpaceQuotaStub func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) updateSpaceQuotaMutex sync.RWMutex - updateSpaceQuotaArgsForCall []struct { - arg1 resources.SpaceQuota - } - updateSpaceQuotaReturns struct { + updateSpaceQuotaArgsForCall []FakeCloudControllerClientUpdateSpaceQuotaArgs + updateSpaceQuotaReturns struct { result1 resources.SpaceQuota result2 ccv3.Warnings result3 error @@ -2774,12 +2421,8 @@ type FakeCloudControllerClient struct { } UpdateStackStub func(string, string, string) (resources.Stack, ccv3.Warnings, error) updateStackMutex sync.RWMutex - updateStackArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - updateStackReturns struct { + updateStackArgsForCall []FakeCloudControllerClientUpdateStackArgs + updateStackReturns struct { result1 resources.Stack result2 ccv3.Warnings result3 error @@ -2791,10 +2434,8 @@ type FakeCloudControllerClient struct { } UpdateTaskCancelStub func(string) (resources.Task, ccv3.Warnings, error) updateTaskCancelMutex sync.RWMutex - updateTaskCancelArgsForCall []struct { - arg1 string - } - updateTaskCancelReturns struct { + updateTaskCancelArgsForCall []FakeCloudControllerClientUpdateTaskCancelArgs + updateTaskCancelReturns struct { result1 resources.Task result2 ccv3.Warnings result3 error @@ -2806,13 +2447,8 @@ type FakeCloudControllerClient struct { } UploadBitsPackageStub func(resources.Package, []ccv3.Resource, io.Reader, int64) (resources.Package, ccv3.Warnings, error) uploadBitsPackageMutex sync.RWMutex - uploadBitsPackageArgsForCall []struct { - arg1 resources.Package - arg2 []ccv3.Resource - arg3 io.Reader - arg4 int64 - } - uploadBitsPackageReturns struct { + uploadBitsPackageArgsForCall []FakeCloudControllerClientUploadBitsPackageArgs + uploadBitsPackageReturns struct { result1 resources.Package result2 ccv3.Warnings result3 error @@ -2824,13 +2460,8 @@ type FakeCloudControllerClient struct { } UploadBuildpackStub func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error) uploadBuildpackMutex sync.RWMutex - uploadBuildpackArgsForCall []struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - } - uploadBuildpackReturns struct { + uploadBuildpackArgsForCall []FakeCloudControllerClientUploadBuildpackArgs + uploadBuildpackReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2842,13 +2473,8 @@ type FakeCloudControllerClient struct { } UploadDropletBitsStub func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error) uploadDropletBitsMutex sync.RWMutex - uploadDropletBitsArgsForCall []struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - } - uploadDropletBitsReturns struct { + uploadDropletBitsArgsForCall []FakeCloudControllerClientUploadDropletBitsArgs + uploadDropletBitsReturns struct { result1 ccv3.JobURL result2 ccv3.Warnings result3 error @@ -2860,11 +2486,8 @@ type FakeCloudControllerClient struct { } UploadPackageStub func(resources.Package, string) (resources.Package, ccv3.Warnings, error) uploadPackageMutex sync.RWMutex - uploadPackageArgsForCall []struct { - arg1 resources.Package - arg2 string - } - uploadPackageReturns struct { + uploadPackageArgsForCall []FakeCloudControllerClientUploadPackageArgs + uploadPackageReturns struct { result1 resources.Package result2 ccv3.Warnings result3 error @@ -2876,9 +2499,8 @@ type FakeCloudControllerClient struct { } WhoAmIStub func() (resources.K8sUser, ccv3.Warnings, error) whoAmIMutex sync.RWMutex - whoAmIArgsForCall []struct { - } - whoAmIReturns struct { + whoAmIArgsForCall []struct{} + whoAmIReturns struct { result1 resources.K8sUser result2 ccv3.Warnings result3 error @@ -2889,46 +2511,1090 @@ type FakeCloudControllerClient struct { result3 error } invocations map[string][][]interface{} + callOrder []string invocationsMutex sync.RWMutex } -func (fake *FakeCloudControllerClient) ApplyOrganizationQuota(arg1 string, arg2 string) (resources.RelationshipList, ccv3.Warnings, error) { - fake.applyOrganizationQuotaMutex.Lock() - ret, specificReturn := fake.applyOrganizationQuotaReturnsOnCall[len(fake.applyOrganizationQuotaArgsForCall)] - fake.applyOrganizationQuotaArgsForCall = append(fake.applyOrganizationQuotaArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) - stub := fake.ApplyOrganizationQuotaStub - fakeReturns := fake.applyOrganizationQuotaReturns - fake.recordInvocation("ApplyOrganizationQuota", []interface{}{arg1, arg2}) - fake.applyOrganizationQuotaMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2, ret.result3 - } - return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +// FakeCloudControllerClientApplyOrganizationQuotaArgs holds the arguments of one call to ApplyOrganizationQuota. +type FakeCloudControllerClientApplyOrganizationQuotaArgs struct { + Arg1 string + Arg2 string } -func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCallCount() int { - fake.applyOrganizationQuotaMutex.RLock() - defer fake.applyOrganizationQuotaMutex.RUnlock() - return len(fake.applyOrganizationQuotaArgsForCall) +// FakeCloudControllerClientApplySpaceQuotaArgs holds the arguments of one call to ApplySpaceQuota. +type FakeCloudControllerClientApplySpaceQuotaArgs struct { + Arg1 string + Arg2 string } -func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCalls(stub func(string, string) (resources.RelationshipList, ccv3.Warnings, error)) { - fake.applyOrganizationQuotaMutex.Lock() - defer fake.applyOrganizationQuotaMutex.Unlock() - fake.ApplyOrganizationQuotaStub = stub +// FakeCloudControllerClientCancelDeploymentArgs holds the arguments of one call to CancelDeployment. +type FakeCloudControllerClientCancelDeploymentArgs struct { + Arg1 string } -func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaArgsForCall(i int) (string, string) { - fake.applyOrganizationQuotaMutex.RLock() +// FakeCloudControllerClientCheckRouteArgs holds the arguments of one call to CheckRoute. +type FakeCloudControllerClientCheckRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeCloudControllerClientContinueDeploymentArgs holds the arguments of one call to ContinueDeployment. +type FakeCloudControllerClientContinueDeploymentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientCopyPackageArgs holds the arguments of one call to CopyPackage. +type FakeCloudControllerClientCopyPackageArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientCreateApplicationArgs holds the arguments of one call to CreateApplication. +type FakeCloudControllerClientCreateApplicationArgs struct { + Arg1 resources.Application +} + +// FakeCloudControllerClientCreateApplicationDeploymentArgs holds the arguments of one call to CreateApplicationDeployment. +type FakeCloudControllerClientCreateApplicationDeploymentArgs struct { + Arg1 resources.Deployment +} + +// FakeCloudControllerClientCreateApplicationProcessScaleArgs holds the arguments of one call to CreateApplicationProcessScale. +type FakeCloudControllerClientCreateApplicationProcessScaleArgs struct { + Arg1 string + Arg2 resources.Process +} + +// FakeCloudControllerClientCreateApplicationTaskArgs holds the arguments of one call to CreateApplicationTask. +type FakeCloudControllerClientCreateApplicationTaskArgs struct { + Arg1 string + Arg2 resources.Task +} + +// FakeCloudControllerClientCreateBuildArgs holds the arguments of one call to CreateBuild. +type FakeCloudControllerClientCreateBuildArgs struct { + Arg1 resources.Build +} + +// FakeCloudControllerClientCreateBuildpackArgs holds the arguments of one call to CreateBuildpack. +type FakeCloudControllerClientCreateBuildpackArgs struct { + Arg1 resources.Buildpack +} + +// FakeCloudControllerClientCreateDomainArgs holds the arguments of one call to CreateDomain. +type FakeCloudControllerClientCreateDomainArgs struct { + Arg1 resources.Domain +} + +// FakeCloudControllerClientCreateDropletArgs holds the arguments of one call to CreateDroplet. +type FakeCloudControllerClientCreateDropletArgs struct { + Arg1 string +} + +// FakeCloudControllerClientCreateIsolationSegmentArgs holds the arguments of one call to CreateIsolationSegment. +type FakeCloudControllerClientCreateIsolationSegmentArgs struct { + Arg1 resources.IsolationSegment +} + +// FakeCloudControllerClientCreateOrganizationArgs holds the arguments of one call to CreateOrganization. +type FakeCloudControllerClientCreateOrganizationArgs struct { + Arg1 string +} + +// FakeCloudControllerClientCreateOrganizationQuotaArgs holds the arguments of one call to CreateOrganizationQuota. +type FakeCloudControllerClientCreateOrganizationQuotaArgs struct { + Arg1 resources.OrganizationQuota +} + +// FakeCloudControllerClientCreatePackageArgs holds the arguments of one call to CreatePackage. +type FakeCloudControllerClientCreatePackageArgs struct { + Arg1 resources.Package +} + +// FakeCloudControllerClientCreateRoleArgs holds the arguments of one call to CreateRole. +type FakeCloudControllerClientCreateRoleArgs struct { + Arg1 resources.Role +} + +// FakeCloudControllerClientCreateRouteArgs holds the arguments of one call to CreateRoute. +type FakeCloudControllerClientCreateRouteArgs struct { + Arg1 resources.Route +} + +// FakeCloudControllerClientCreateRouteBindingArgs holds the arguments of one call to CreateRouteBinding. +type FakeCloudControllerClientCreateRouteBindingArgs struct { + Arg1 resources.RouteBinding +} + +// FakeCloudControllerClientCreateRoutePolicyArgs holds the arguments of one call to CreateRoutePolicy. +type FakeCloudControllerClientCreateRoutePolicyArgs struct { + Arg1 resources.RoutePolicy +} + +// FakeCloudControllerClientCreateSecurityGroupArgs holds the arguments of one call to CreateSecurityGroup. +type FakeCloudControllerClientCreateSecurityGroupArgs struct { + Arg1 resources.SecurityGroup +} + +// FakeCloudControllerClientCreateServiceAccountArgs holds the arguments of one call to CreateServiceAccount. +type FakeCloudControllerClientCreateServiceAccountArgs struct { + Arg1 resources.ServiceAccount +} + +// FakeCloudControllerClientCreateServiceBrokerArgs holds the arguments of one call to CreateServiceBroker. +type FakeCloudControllerClientCreateServiceBrokerArgs struct { + Arg1 resources.ServiceBroker +} + +// FakeCloudControllerClientCreateServiceCredentialBindingArgs holds the arguments of one call to CreateServiceCredentialBinding. +type FakeCloudControllerClientCreateServiceCredentialBindingArgs struct { + Arg1 resources.ServiceCredentialBinding +} + +// FakeCloudControllerClientCreateServiceInstanceArgs holds the arguments of one call to CreateServiceInstance. +type FakeCloudControllerClientCreateServiceInstanceArgs struct { + Arg1 resources.ServiceInstance +} + +// FakeCloudControllerClientCreateSpaceArgs holds the arguments of one call to CreateSpace. +type FakeCloudControllerClientCreateSpaceArgs struct { + Arg1 resources.Space +} + +// FakeCloudControllerClientCreateSpaceQuotaArgs holds the arguments of one call to CreateSpaceQuota. +type FakeCloudControllerClientCreateSpaceQuotaArgs struct { + Arg1 resources.SpaceQuota +} + +// FakeCloudControllerClientCreateUserArgs holds the arguments of one call to CreateUser. +type FakeCloudControllerClientCreateUserArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteApplicationArgs holds the arguments of one call to DeleteApplication. +type FakeCloudControllerClientDeleteApplicationArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteApplicationProcessInstanceArgs holds the arguments of one call to DeleteApplicationProcessInstance. +type FakeCloudControllerClientDeleteApplicationProcessInstanceArgs struct { + Arg1 string + Arg2 string + Arg3 int +} + +// FakeCloudControllerClientDeleteBuildpackArgs holds the arguments of one call to DeleteBuildpack. +type FakeCloudControllerClientDeleteBuildpackArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteDomainArgs holds the arguments of one call to DeleteDomain. +type FakeCloudControllerClientDeleteDomainArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteIsolationSegmentArgs holds the arguments of one call to DeleteIsolationSegment. +type FakeCloudControllerClientDeleteIsolationSegmentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs holds the arguments of one call to DeleteIsolationSegmentOrganization. +type FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientDeleteOrganizationArgs holds the arguments of one call to DeleteOrganization. +type FakeCloudControllerClientDeleteOrganizationArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteOrganizationQuotaArgs holds the arguments of one call to DeleteOrganizationQuota. +type FakeCloudControllerClientDeleteOrganizationQuotaArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteOrphanedRoutesArgs holds the arguments of one call to DeleteOrphanedRoutes. +type FakeCloudControllerClientDeleteOrphanedRoutesArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteRoleArgs holds the arguments of one call to DeleteRole. +type FakeCloudControllerClientDeleteRoleArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteRouteArgs holds the arguments of one call to DeleteRoute. +type FakeCloudControllerClientDeleteRouteArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteRouteBindingArgs holds the arguments of one call to DeleteRouteBinding. +type FakeCloudControllerClientDeleteRouteBindingArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteRoutePolicyArgs holds the arguments of one call to DeleteRoutePolicy. +type FakeCloudControllerClientDeleteRoutePolicyArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteSecurityGroupArgs holds the arguments of one call to DeleteSecurityGroup. +type FakeCloudControllerClientDeleteSecurityGroupArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteServiceAccountArgs holds the arguments of one call to DeleteServiceAccount. +type FakeCloudControllerClientDeleteServiceAccountArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteServiceBrokerArgs holds the arguments of one call to DeleteServiceBroker. +type FakeCloudControllerClientDeleteServiceBrokerArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteServiceCredentialBindingArgs holds the arguments of one call to DeleteServiceCredentialBinding. +type FakeCloudControllerClientDeleteServiceCredentialBindingArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteServiceInstanceArgs holds the arguments of one call to DeleteServiceInstance. +type FakeCloudControllerClientDeleteServiceInstanceArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientDeleteServicePlanVisibilityArgs holds the arguments of one call to DeleteServicePlanVisibility. +type FakeCloudControllerClientDeleteServicePlanVisibilityArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientDeleteSpaceArgs holds the arguments of one call to DeleteSpace. +type FakeCloudControllerClientDeleteSpaceArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteSpaceQuotaArgs holds the arguments of one call to DeleteSpaceQuota. +type FakeCloudControllerClientDeleteSpaceQuotaArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDeleteUserArgs holds the arguments of one call to DeleteUser. +type FakeCloudControllerClientDeleteUserArgs struct { + Arg1 string +} + +// FakeCloudControllerClientDownloadDropletArgs holds the arguments of one call to DownloadDroplet. +type FakeCloudControllerClientDownloadDropletArgs struct { + Arg1 string +} + +// FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs holds the arguments of one call to EntitleIsolationSegmentToOrganizations. +type FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs struct { + Arg1 string + Arg2 []string +} + +// FakeCloudControllerClientGetAppFeatureArgs holds the arguments of one call to GetAppFeature. +type FakeCloudControllerClientGetAppFeatureArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetApplicationByNameAndSpaceArgs holds the arguments of one call to GetApplicationByNameAndSpace. +type FakeCloudControllerClientGetApplicationByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetApplicationDropletCurrentArgs holds the arguments of one call to GetApplicationDropletCurrent. +type FakeCloudControllerClientGetApplicationDropletCurrentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationEnvironmentArgs holds the arguments of one call to GetApplicationEnvironment. +type FakeCloudControllerClientGetApplicationEnvironmentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationManifestArgs holds the arguments of one call to GetApplicationManifest. +type FakeCloudControllerClientGetApplicationManifestArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationProcessByTypeArgs holds the arguments of one call to GetApplicationProcessByType. +type FakeCloudControllerClientGetApplicationProcessByTypeArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetApplicationProcessesArgs holds the arguments of one call to GetApplicationProcesses. +type FakeCloudControllerClientGetApplicationProcessesArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationRevisionsArgs holds the arguments of one call to GetApplicationRevisions. +type FakeCloudControllerClientGetApplicationRevisionsArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetApplicationRevisionsDeployedArgs holds the arguments of one call to GetApplicationRevisionsDeployed. +type FakeCloudControllerClientGetApplicationRevisionsDeployedArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationRoutesArgs holds the arguments of one call to GetApplicationRoutes. +type FakeCloudControllerClientGetApplicationRoutesArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetApplicationTasksArgs holds the arguments of one call to GetApplicationTasks. +type FakeCloudControllerClientGetApplicationTasksArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetApplicationsArgs holds the arguments of one call to GetApplications. +type FakeCloudControllerClientGetApplicationsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetBuildArgs holds the arguments of one call to GetBuild. +type FakeCloudControllerClientGetBuildArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetBuildpacksArgs holds the arguments of one call to GetBuildpacks. +type FakeCloudControllerClientGetBuildpacksArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetDefaultDomainArgs holds the arguments of one call to GetDefaultDomain. +type FakeCloudControllerClientGetDefaultDomainArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetDeploymentArgs holds the arguments of one call to GetDeployment. +type FakeCloudControllerClientGetDeploymentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetDeploymentsArgs holds the arguments of one call to GetDeployments. +type FakeCloudControllerClientGetDeploymentsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetDomainArgs holds the arguments of one call to GetDomain. +type FakeCloudControllerClientGetDomainArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetDomainsArgs holds the arguments of one call to GetDomains. +type FakeCloudControllerClientGetDomainsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetDropletArgs holds the arguments of one call to GetDroplet. +type FakeCloudControllerClientGetDropletArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetDropletsArgs holds the arguments of one call to GetDroplets. +type FakeCloudControllerClientGetDropletsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetEnvironmentVariableGroupArgs holds the arguments of one call to GetEnvironmentVariableGroup. +type FakeCloudControllerClientGetEnvironmentVariableGroupArgs struct { + Arg1 constant.EnvironmentVariableGroupName +} + +// FakeCloudControllerClientGetEnvironmentVariablesByURLArgs holds the arguments of one call to GetEnvironmentVariablesByURL. +type FakeCloudControllerClientGetEnvironmentVariablesByURLArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetEventsArgs holds the arguments of one call to GetEvents. +type FakeCloudControllerClientGetEventsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetFeatureFlagArgs holds the arguments of one call to GetFeatureFlag. +type FakeCloudControllerClientGetFeatureFlagArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetIsolationSegmentArgs holds the arguments of one call to GetIsolationSegment. +type FakeCloudControllerClientGetIsolationSegmentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs holds the arguments of one call to GetIsolationSegmentOrganizations. +type FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetIsolationSegmentsArgs holds the arguments of one call to GetIsolationSegments. +type FakeCloudControllerClientGetIsolationSegmentsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetNewApplicationProcessesArgs holds the arguments of one call to GetNewApplicationProcesses. +type FakeCloudControllerClientGetNewApplicationProcessesArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetOrganizationArgs holds the arguments of one call to GetOrganization. +type FakeCloudControllerClientGetOrganizationArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs holds the arguments of one call to GetOrganizationDefaultIsolationSegment. +type FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetOrganizationDomainsArgs holds the arguments of one call to GetOrganizationDomains. +type FakeCloudControllerClientGetOrganizationDomainsArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetOrganizationQuotaArgs holds the arguments of one call to GetOrganizationQuota. +type FakeCloudControllerClientGetOrganizationQuotaArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetOrganizationQuotasArgs holds the arguments of one call to GetOrganizationQuotas. +type FakeCloudControllerClientGetOrganizationQuotasArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetOrganizationsArgs holds the arguments of one call to GetOrganizations. +type FakeCloudControllerClientGetOrganizationsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetPackageArgs holds the arguments of one call to GetPackage. +type FakeCloudControllerClientGetPackageArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetPackageDropletsArgs holds the arguments of one call to GetPackageDroplets. +type FakeCloudControllerClientGetPackageDropletsArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetPackagesArgs holds the arguments of one call to GetPackages. +type FakeCloudControllerClientGetPackagesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetProcessArgs holds the arguments of one call to GetProcess. +type FakeCloudControllerClientGetProcessArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetProcessInstancesArgs holds the arguments of one call to GetProcessInstances. +type FakeCloudControllerClientGetProcessInstancesArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetProcessSidecarsArgs holds the arguments of one call to GetProcessSidecars. +type FakeCloudControllerClientGetProcessSidecarsArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetProcessesArgs holds the arguments of one call to GetProcesses. +type FakeCloudControllerClientGetProcessesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetRolesArgs holds the arguments of one call to GetRoles. +type FakeCloudControllerClientGetRolesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetRouteBindingsArgs holds the arguments of one call to GetRouteBindings. +type FakeCloudControllerClientGetRouteBindingsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetRouteDestinationsArgs holds the arguments of one call to GetRouteDestinations. +type FakeCloudControllerClientGetRouteDestinationsArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetRoutePoliciesArgs holds the arguments of one call to GetRoutePolicies. +type FakeCloudControllerClientGetRoutePoliciesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetRoutesArgs holds the arguments of one call to GetRoutes. +type FakeCloudControllerClientGetRoutesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetRunningSecurityGroupsArgs holds the arguments of one call to GetRunningSecurityGroups. +type FakeCloudControllerClientGetRunningSecurityGroupsArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetSSHEnabledArgs holds the arguments of one call to GetSSHEnabled. +type FakeCloudControllerClientGetSSHEnabledArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetSecurityGroupsArgs holds the arguments of one call to GetSecurityGroups. +type FakeCloudControllerClientGetSecurityGroupsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceAccountArgs holds the arguments of one call to GetServiceAccount. +type FakeCloudControllerClientGetServiceAccountArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceAccountsArgs holds the arguments of one call to GetServiceAccounts. +type FakeCloudControllerClientGetServiceAccountsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceBrokersArgs holds the arguments of one call to GetServiceBrokers. +type FakeCloudControllerClientGetServiceBrokersArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs holds the arguments of one call to GetServiceCredentialBindingDetails. +type FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceCredentialBindingsArgs holds the arguments of one call to GetServiceCredentialBindings. +type FakeCloudControllerClientGetServiceCredentialBindingsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceInstanceByGUIDArgs holds the arguments of one call to GetServiceInstanceByGUID. +type FakeCloudControllerClientGetServiceInstanceByGUIDArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs holds the arguments of one call to GetServiceInstanceByNameAndSpace. +type FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceInstanceParametersArgs holds the arguments of one call to GetServiceInstanceParameters. +type FakeCloudControllerClientGetServiceInstanceParametersArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs holds the arguments of one call to GetServiceInstanceSharedSpaces. +type FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs holds the arguments of one call to GetServiceInstanceUsageSummary. +type FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceInstancesArgs holds the arguments of one call to GetServiceInstances. +type FakeCloudControllerClientGetServiceInstancesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServiceOfferingByGUIDArgs holds the arguments of one call to GetServiceOfferingByGUID. +type FakeCloudControllerClientGetServiceOfferingByGUIDArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs holds the arguments of one call to GetServiceOfferingByNameAndBroker. +type FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetServiceOfferingsArgs holds the arguments of one call to GetServiceOfferings. +type FakeCloudControllerClientGetServiceOfferingsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServicePlanByGUIDArgs holds the arguments of one call to GetServicePlanByGUID. +type FakeCloudControllerClientGetServicePlanByGUIDArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServicePlanVisibilityArgs holds the arguments of one call to GetServicePlanVisibility. +type FakeCloudControllerClientGetServicePlanVisibilityArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetServicePlansArgs holds the arguments of one call to GetServicePlans. +type FakeCloudControllerClientGetServicePlansArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServicePlansWithOfferingsArgs holds the arguments of one call to GetServicePlansWithOfferings. +type FakeCloudControllerClientGetServicePlansWithOfferingsArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs holds the arguments of one call to GetServicePlansWithSpaceAndOrganization. +type FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetSpaceFeatureArgs holds the arguments of one call to GetSpaceFeature. +type FakeCloudControllerClientGetSpaceFeatureArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientGetSpaceIsolationSegmentArgs holds the arguments of one call to GetSpaceIsolationSegment. +type FakeCloudControllerClientGetSpaceIsolationSegmentArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetSpaceManifestDiffArgs holds the arguments of one call to GetSpaceManifestDiff. +type FakeCloudControllerClientGetSpaceManifestDiffArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeCloudControllerClientGetSpaceQuotaArgs holds the arguments of one call to GetSpaceQuota. +type FakeCloudControllerClientGetSpaceQuotaArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetSpaceQuotasArgs holds the arguments of one call to GetSpaceQuotas. +type FakeCloudControllerClientGetSpaceQuotasArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetSpacesArgs holds the arguments of one call to GetSpaces. +type FakeCloudControllerClientGetSpacesArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetStacksArgs holds the arguments of one call to GetStacks. +type FakeCloudControllerClientGetStacksArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientGetStagingSecurityGroupsArgs holds the arguments of one call to GetStagingSecurityGroups. +type FakeCloudControllerClientGetStagingSecurityGroupsArgs struct { + Arg1 string + Arg2 []ccv3.Query +} + +// FakeCloudControllerClientGetTaskArgs holds the arguments of one call to GetTask. +type FakeCloudControllerClientGetTaskArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetUserArgs holds the arguments of one call to GetUser. +type FakeCloudControllerClientGetUserArgs struct { + Arg1 string +} + +// FakeCloudControllerClientGetUsersArgs holds the arguments of one call to GetUsers. +type FakeCloudControllerClientGetUsersArgs struct { + Arg1 []ccv3.Query +} + +// FakeCloudControllerClientMakeRequestSendReceiveRawArgs holds the arguments of one call to MakeRequestSendReceiveRaw. +type FakeCloudControllerClientMakeRequestSendReceiveRawArgs struct { + Arg1 string + Arg2 string + Arg3 http.Header + Arg4 []byte +} + +// FakeCloudControllerClientMapRouteArgs holds the arguments of one call to MapRoute. +type FakeCloudControllerClientMapRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeCloudControllerClientMoveRouteArgs holds the arguments of one call to MoveRoute. +type FakeCloudControllerClientMoveRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientPollJobArgs holds the arguments of one call to PollJob. +type FakeCloudControllerClientPollJobArgs struct { + Arg1 ccv3.JobURL +} + +// FakeCloudControllerClientPollJobForStateArgs holds the arguments of one call to PollJobForState. +type FakeCloudControllerClientPollJobForStateArgs struct { + Arg1 ccv3.JobURL + Arg2 constant.JobState +} + +// FakeCloudControllerClientPollJobToEventStreamArgs holds the arguments of one call to PollJobToEventStream. +type FakeCloudControllerClientPollJobToEventStreamArgs struct { + Arg1 ccv3.JobURL +} + +// FakeCloudControllerClientPurgeServiceOfferingArgs holds the arguments of one call to PurgeServiceOffering. +type FakeCloudControllerClientPurgeServiceOfferingArgs struct { + Arg1 string +} + +// FakeCloudControllerClientResourceMatchArgs holds the arguments of one call to ResourceMatch. +type FakeCloudControllerClientResourceMatchArgs struct { + Arg1 []ccv3.Resource +} + +// FakeCloudControllerClientSetApplicationDropletArgs holds the arguments of one call to SetApplicationDroplet. +type FakeCloudControllerClientSetApplicationDropletArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientSharePrivateDomainToOrgsArgs holds the arguments of one call to SharePrivateDomainToOrgs. +type FakeCloudControllerClientSharePrivateDomainToOrgsArgs struct { + Arg1 string + Arg2 ccv3.SharedOrgs +} + +// FakeCloudControllerClientShareRouteArgs holds the arguments of one call to ShareRoute. +type FakeCloudControllerClientShareRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientShareServiceInstanceToSpacesArgs holds the arguments of one call to ShareServiceInstanceToSpaces. +type FakeCloudControllerClientShareServiceInstanceToSpacesArgs struct { + Arg1 string + Arg2 []string +} + +// FakeCloudControllerClientTargetCFArgs holds the arguments of one call to TargetCF. +type FakeCloudControllerClientTargetCFArgs struct { + Arg1 ccv3.TargetSettings +} + +// FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs holds the arguments of one call to UnbindSecurityGroupRunningSpace. +type FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs holds the arguments of one call to UnbindSecurityGroupStagingSpace. +type FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnmapRouteArgs holds the arguments of one call to UnmapRoute. +type FakeCloudControllerClientUnmapRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnsetSpaceQuotaArgs holds the arguments of one call to UnsetSpaceQuota. +type FakeCloudControllerClientUnsetSpaceQuotaArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs holds the arguments of one call to UnsharePrivateDomainFromOrg. +type FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnshareRouteArgs holds the arguments of one call to UnshareRoute. +type FakeCloudControllerClientUnshareRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs holds the arguments of one call to UnshareServiceInstanceFromSpace. +type FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUpdateAppFeatureArgs holds the arguments of one call to UpdateAppFeature. +type FakeCloudControllerClientUpdateAppFeatureArgs struct { + Arg1 string + Arg2 bool + Arg3 string +} + +// FakeCloudControllerClientUpdateApplicationArgs holds the arguments of one call to UpdateApplication. +type FakeCloudControllerClientUpdateApplicationArgs struct { + Arg1 resources.Application +} + +// FakeCloudControllerClientUpdateApplicationApplyManifestArgs holds the arguments of one call to UpdateApplicationApplyManifest. +type FakeCloudControllerClientUpdateApplicationApplyManifestArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs holds the arguments of one call to UpdateApplicationEnvironmentVariables. +type FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs struct { + Arg1 string + Arg2 resources.EnvironmentVariables +} + +// FakeCloudControllerClientUpdateApplicationNameArgs holds the arguments of one call to UpdateApplicationName. +type FakeCloudControllerClientUpdateApplicationNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUpdateApplicationRestartArgs holds the arguments of one call to UpdateApplicationRestart. +type FakeCloudControllerClientUpdateApplicationRestartArgs struct { + Arg1 string +} + +// FakeCloudControllerClientUpdateApplicationServiceAccountArgs holds the arguments of one call to UpdateApplicationServiceAccount. +type FakeCloudControllerClientUpdateApplicationServiceAccountArgs struct { + Arg1 string + Arg2 resources.Relationship +} + +// FakeCloudControllerClientUpdateApplicationStartArgs holds the arguments of one call to UpdateApplicationStart. +type FakeCloudControllerClientUpdateApplicationStartArgs struct { + Arg1 string +} + +// FakeCloudControllerClientUpdateApplicationStopArgs holds the arguments of one call to UpdateApplicationStop. +type FakeCloudControllerClientUpdateApplicationStopArgs struct { + Arg1 string +} + +// FakeCloudControllerClientUpdateBuildpackArgs holds the arguments of one call to UpdateBuildpack. +type FakeCloudControllerClientUpdateBuildpackArgs struct { + Arg1 resources.Buildpack +} + +// FakeCloudControllerClientUpdateDestinationArgs holds the arguments of one call to UpdateDestination. +type FakeCloudControllerClientUpdateDestinationArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs holds the arguments of one call to UpdateEnvironmentVariableGroup. +type FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs struct { + Arg1 constant.EnvironmentVariableGroupName + Arg2 resources.EnvironmentVariables +} + +// FakeCloudControllerClientUpdateFeatureFlagArgs holds the arguments of one call to UpdateFeatureFlag. +type FakeCloudControllerClientUpdateFeatureFlagArgs struct { + Arg1 resources.FeatureFlag +} + +// FakeCloudControllerClientUpdateOrganizationArgs holds the arguments of one call to UpdateOrganization. +type FakeCloudControllerClientUpdateOrganizationArgs struct { + Arg1 resources.Organization +} + +// FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs holds the arguments of one call to UpdateOrganizationDefaultIsolationSegmentRelationship. +type FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUpdateOrganizationQuotaArgs holds the arguments of one call to UpdateOrganizationQuota. +type FakeCloudControllerClientUpdateOrganizationQuotaArgs struct { + Arg1 resources.OrganizationQuota +} + +// FakeCloudControllerClientUpdateProcessArgs holds the arguments of one call to UpdateProcess. +type FakeCloudControllerClientUpdateProcessArgs struct { + Arg1 resources.Process +} + +// FakeCloudControllerClientUpdateResourceMetadataArgs holds the arguments of one call to UpdateResourceMetadata. +type FakeCloudControllerClientUpdateResourceMetadataArgs struct { + Arg1 string + Arg2 string + Arg3 resources.Metadata +} + +// FakeCloudControllerClientUpdateRouteArgs holds the arguments of one call to UpdateRoute. +type FakeCloudControllerClientUpdateRouteArgs struct { + Arg1 string + Arg2 map[string]*string +} + +// FakeCloudControllerClientUpdateSecurityGroupArgs holds the arguments of one call to UpdateSecurityGroup. +type FakeCloudControllerClientUpdateSecurityGroupArgs struct { + Arg1 resources.SecurityGroup +} + +// FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs holds the arguments of one call to UpdateSecurityGroupRunningSpace. +type FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs struct { + Arg1 string + Arg2 []string +} + +// FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs holds the arguments of one call to UpdateSecurityGroupStagingSpace. +type FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs struct { + Arg1 string + Arg2 []string +} + +// FakeCloudControllerClientUpdateServiceAccountEnabledArgs holds the arguments of one call to UpdateServiceAccountEnabled. +type FakeCloudControllerClientUpdateServiceAccountEnabledArgs struct { + Arg1 string + Arg2 bool +} + +// FakeCloudControllerClientUpdateServiceBrokerArgs holds the arguments of one call to UpdateServiceBroker. +type FakeCloudControllerClientUpdateServiceBrokerArgs struct { + Arg1 string + Arg2 resources.ServiceBroker +} + +// FakeCloudControllerClientUpdateServiceInstanceArgs holds the arguments of one call to UpdateServiceInstance. +type FakeCloudControllerClientUpdateServiceInstanceArgs struct { + Arg1 string + Arg2 resources.ServiceInstance +} + +// FakeCloudControllerClientUpdateServicePlanVisibilityArgs holds the arguments of one call to UpdateServicePlanVisibility. +type FakeCloudControllerClientUpdateServicePlanVisibilityArgs struct { + Arg1 string + Arg2 resources.ServicePlanVisibility +} + +// FakeCloudControllerClientUpdateSpaceArgs holds the arguments of one call to UpdateSpace. +type FakeCloudControllerClientUpdateSpaceArgs struct { + Arg1 resources.Space +} + +// FakeCloudControllerClientUpdateSpaceApplyManifestArgs holds the arguments of one call to UpdateSpaceApplyManifest. +type FakeCloudControllerClientUpdateSpaceApplyManifestArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeCloudControllerClientUpdateSpaceFeatureArgs holds the arguments of one call to UpdateSpaceFeature. +type FakeCloudControllerClientUpdateSpaceFeatureArgs struct { + Arg1 string + Arg2 bool + Arg3 string +} + +// FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs holds the arguments of one call to UpdateSpaceIsolationSegmentRelationship. +type FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs struct { + Arg1 string + Arg2 string +} + +// FakeCloudControllerClientUpdateSpaceQuotaArgs holds the arguments of one call to UpdateSpaceQuota. +type FakeCloudControllerClientUpdateSpaceQuotaArgs struct { + Arg1 resources.SpaceQuota +} + +// FakeCloudControllerClientUpdateStackArgs holds the arguments of one call to UpdateStack. +type FakeCloudControllerClientUpdateStackArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeCloudControllerClientUpdateTaskCancelArgs holds the arguments of one call to UpdateTaskCancel. +type FakeCloudControllerClientUpdateTaskCancelArgs struct { + Arg1 string +} + +// FakeCloudControllerClientUploadBitsPackageArgs holds the arguments of one call to UploadBitsPackage. +type FakeCloudControllerClientUploadBitsPackageArgs struct { + Arg1 resources.Package + Arg2 []ccv3.Resource + Arg3 io.Reader + Arg4 int64 +} + +// FakeCloudControllerClientUploadBuildpackArgs holds the arguments of one call to UploadBuildpack. +type FakeCloudControllerClientUploadBuildpackArgs struct { + Arg1 string + Arg2 string + Arg3 io.Reader + Arg4 int64 +} + +// FakeCloudControllerClientUploadDropletBitsArgs holds the arguments of one call to UploadDropletBits. +type FakeCloudControllerClientUploadDropletBitsArgs struct { + Arg1 string + Arg2 string + Arg3 io.Reader + Arg4 int64 +} + +// FakeCloudControllerClientUploadPackageArgs holds the arguments of one call to UploadPackage. +type FakeCloudControllerClientUploadPackageArgs struct { + Arg1 resources.Package + Arg2 string +} + +func (fake *FakeCloudControllerClient) ApplyOrganizationQuota(arg1 string, arg2 string) (resources.RelationshipList, ccv3.Warnings, error) { + fake.applyOrganizationQuotaMutex.Lock() + ret, specificReturn := fake.applyOrganizationQuotaReturnsOnCall[len(fake.applyOrganizationQuotaArgsForCall)] + fake.applyOrganizationQuotaArgsForCall = append(fake.applyOrganizationQuotaArgsForCall, FakeCloudControllerClientApplyOrganizationQuotaArgs{arg1, arg2}) + stub := fake.ApplyOrganizationQuotaStub + fakeReturns := fake.applyOrganizationQuotaReturns + fake.recordInvocation("ApplyOrganizationQuota", []interface{}{arg1, arg2}) + fake.applyOrganizationQuotaMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCallCount() int { + fake.applyOrganizationQuotaMutex.RLock() + defer fake.applyOrganizationQuotaMutex.RUnlock() + return len(fake.applyOrganizationQuotaArgsForCall) +} + +func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCalls(stub func(string, string) (resources.RelationshipList, ccv3.Warnings, error)) { + fake.applyOrganizationQuotaMutex.Lock() + defer fake.applyOrganizationQuotaMutex.Unlock() + fake.ApplyOrganizationQuotaStub = stub +} + +func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaArgsForCall(i int) (string, string) { + fake.applyOrganizationQuotaMutex.RLock() defer fake.applyOrganizationQuotaMutex.RUnlock() argsForCall := fake.applyOrganizationQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaArgs() []FakeCloudControllerClientApplyOrganizationQuotaArgs { + fake.applyOrganizationQuotaMutex.RLock() + defer fake.applyOrganizationQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientApplyOrganizationQuotaArgs, len(fake.applyOrganizationQuotaArgsForCall)) + copy(args, fake.applyOrganizationQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) { @@ -2963,10 +3629,7 @@ func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaReturnsOnCall(i int func (fake *FakeCloudControllerClient) ApplySpaceQuota(arg1 string, arg2 string) (resources.RelationshipList, ccv3.Warnings, error) { fake.applySpaceQuotaMutex.Lock() ret, specificReturn := fake.applySpaceQuotaReturnsOnCall[len(fake.applySpaceQuotaArgsForCall)] - fake.applySpaceQuotaArgsForCall = append(fake.applySpaceQuotaArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.applySpaceQuotaArgsForCall = append(fake.applySpaceQuotaArgsForCall, FakeCloudControllerClientApplySpaceQuotaArgs{arg1, arg2}) stub := fake.ApplySpaceQuotaStub fakeReturns := fake.applySpaceQuotaReturns fake.recordInvocation("ApplySpaceQuota", []interface{}{arg1, arg2}) @@ -2996,7 +3659,15 @@ func (fake *FakeCloudControllerClient) ApplySpaceQuotaArgsForCall(i int) (string fake.applySpaceQuotaMutex.RLock() defer fake.applySpaceQuotaMutex.RUnlock() argsForCall := fake.applySpaceQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) ApplySpaceQuotaArgs() []FakeCloudControllerClientApplySpaceQuotaArgs { + fake.applySpaceQuotaMutex.RLock() + defer fake.applySpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientApplySpaceQuotaArgs, len(fake.applySpaceQuotaArgsForCall)) + copy(args, fake.applySpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) ApplySpaceQuotaReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) { @@ -3031,9 +3702,7 @@ func (fake *FakeCloudControllerClient) ApplySpaceQuotaReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) CancelDeployment(arg1 string) (ccv3.Warnings, error) { fake.cancelDeploymentMutex.Lock() ret, specificReturn := fake.cancelDeploymentReturnsOnCall[len(fake.cancelDeploymentArgsForCall)] - fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, struct { - arg1 string - }{arg1}) + fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, FakeCloudControllerClientCancelDeploymentArgs{arg1}) stub := fake.CancelDeploymentStub fakeReturns := fake.cancelDeploymentReturns fake.recordInvocation("CancelDeployment", []interface{}{arg1}) @@ -3063,7 +3732,15 @@ func (fake *FakeCloudControllerClient) CancelDeploymentArgsForCall(i int) string fake.cancelDeploymentMutex.RLock() defer fake.cancelDeploymentMutex.RUnlock() argsForCall := fake.cancelDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CancelDeploymentArgs() []FakeCloudControllerClientCancelDeploymentArgs { + fake.cancelDeploymentMutex.RLock() + defer fake.cancelDeploymentMutex.RUnlock() + args := make([]FakeCloudControllerClientCancelDeploymentArgs, len(fake.cancelDeploymentArgsForCall)) + copy(args, fake.cancelDeploymentArgsForCall) + return args } func (fake *FakeCloudControllerClient) CancelDeploymentReturns(result1 ccv3.Warnings, result2 error) { @@ -3095,12 +3772,7 @@ func (fake *FakeCloudControllerClient) CancelDeploymentReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) CheckRoute(arg1 string, arg2 string, arg3 string, arg4 int) (bool, ccv3.Warnings, error) { fake.checkRouteMutex.Lock() ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)] - fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, FakeCloudControllerClientCheckRouteArgs{arg1, arg2, arg3, arg4}) stub := fake.CheckRouteStub fakeReturns := fake.checkRouteReturns fake.recordInvocation("CheckRoute", []interface{}{arg1, arg2, arg3, arg4}) @@ -3130,7 +3802,15 @@ func (fake *FakeCloudControllerClient) CheckRouteArgsForCall(i int) (string, str fake.checkRouteMutex.RLock() defer fake.checkRouteMutex.RUnlock() argsForCall := fake.checkRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) CheckRouteArgs() []FakeCloudControllerClientCheckRouteArgs { + fake.checkRouteMutex.RLock() + defer fake.checkRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientCheckRouteArgs, len(fake.checkRouteArgsForCall)) + copy(args, fake.checkRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) CheckRouteReturns(result1 bool, result2 ccv3.Warnings, result3 error) { @@ -3165,9 +3845,7 @@ func (fake *FakeCloudControllerClient) CheckRouteReturnsOnCall(i int, result1 bo func (fake *FakeCloudControllerClient) ContinueDeployment(arg1 string) (ccv3.Warnings, error) { fake.continueDeploymentMutex.Lock() ret, specificReturn := fake.continueDeploymentReturnsOnCall[len(fake.continueDeploymentArgsForCall)] - fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, struct { - arg1 string - }{arg1}) + fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, FakeCloudControllerClientContinueDeploymentArgs{arg1}) stub := fake.ContinueDeploymentStub fakeReturns := fake.continueDeploymentReturns fake.recordInvocation("ContinueDeployment", []interface{}{arg1}) @@ -3197,7 +3875,15 @@ func (fake *FakeCloudControllerClient) ContinueDeploymentArgsForCall(i int) stri fake.continueDeploymentMutex.RLock() defer fake.continueDeploymentMutex.RUnlock() argsForCall := fake.continueDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) ContinueDeploymentArgs() []FakeCloudControllerClientContinueDeploymentArgs { + fake.continueDeploymentMutex.RLock() + defer fake.continueDeploymentMutex.RUnlock() + args := make([]FakeCloudControllerClientContinueDeploymentArgs, len(fake.continueDeploymentArgsForCall)) + copy(args, fake.continueDeploymentArgsForCall) + return args } func (fake *FakeCloudControllerClient) ContinueDeploymentReturns(result1 ccv3.Warnings, result2 error) { @@ -3229,10 +3915,7 @@ func (fake *FakeCloudControllerClient) ContinueDeploymentReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) CopyPackage(arg1 string, arg2 string) (resources.Package, ccv3.Warnings, error) { fake.copyPackageMutex.Lock() ret, specificReturn := fake.copyPackageReturnsOnCall[len(fake.copyPackageArgsForCall)] - fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, FakeCloudControllerClientCopyPackageArgs{arg1, arg2}) stub := fake.CopyPackageStub fakeReturns := fake.copyPackageReturns fake.recordInvocation("CopyPackage", []interface{}{arg1, arg2}) @@ -3262,7 +3945,15 @@ func (fake *FakeCloudControllerClient) CopyPackageArgsForCall(i int) (string, st fake.copyPackageMutex.RLock() defer fake.copyPackageMutex.RUnlock() argsForCall := fake.copyPackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) CopyPackageArgs() []FakeCloudControllerClientCopyPackageArgs { + fake.copyPackageMutex.RLock() + defer fake.copyPackageMutex.RUnlock() + args := make([]FakeCloudControllerClientCopyPackageArgs, len(fake.copyPackageArgsForCall)) + copy(args, fake.copyPackageArgsForCall) + return args } func (fake *FakeCloudControllerClient) CopyPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) { @@ -3297,9 +3988,7 @@ func (fake *FakeCloudControllerClient) CopyPackageReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) CreateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) { fake.createApplicationMutex.Lock() ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)] - fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, struct { - arg1 resources.Application - }{arg1}) + fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, FakeCloudControllerClientCreateApplicationArgs{arg1}) stub := fake.CreateApplicationStub fakeReturns := fake.createApplicationReturns fake.recordInvocation("CreateApplication", []interface{}{arg1}) @@ -3325,11 +4014,19 @@ func (fake *FakeCloudControllerClient) CreateApplicationCalls(stub func(resource fake.CreateApplicationStub = stub } -func (fake *FakeCloudControllerClient) CreateApplicationArgsForCall(i int) resources.Application { +func (fake *FakeCloudControllerClient) CreateApplicationArgsForCall(i int) resources.Application { + fake.createApplicationMutex.RLock() + defer fake.createApplicationMutex.RUnlock() + argsForCall := fake.createApplicationArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateApplicationArgs() []FakeCloudControllerClientCreateApplicationArgs { fake.createApplicationMutex.RLock() defer fake.createApplicationMutex.RUnlock() - argsForCall := fake.createApplicationArgsForCall[i] - return argsForCall.arg1 + args := make([]FakeCloudControllerClientCreateApplicationArgs, len(fake.createApplicationArgsForCall)) + copy(args, fake.createApplicationArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateApplicationReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -3364,9 +4061,7 @@ func (fake *FakeCloudControllerClient) CreateApplicationReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) CreateApplicationDeployment(arg1 resources.Deployment) (string, ccv3.Warnings, error) { fake.createApplicationDeploymentMutex.Lock() ret, specificReturn := fake.createApplicationDeploymentReturnsOnCall[len(fake.createApplicationDeploymentArgsForCall)] - fake.createApplicationDeploymentArgsForCall = append(fake.createApplicationDeploymentArgsForCall, struct { - arg1 resources.Deployment - }{arg1}) + fake.createApplicationDeploymentArgsForCall = append(fake.createApplicationDeploymentArgsForCall, FakeCloudControllerClientCreateApplicationDeploymentArgs{arg1}) stub := fake.CreateApplicationDeploymentStub fakeReturns := fake.createApplicationDeploymentReturns fake.recordInvocation("CreateApplicationDeployment", []interface{}{arg1}) @@ -3396,7 +4091,15 @@ func (fake *FakeCloudControllerClient) CreateApplicationDeploymentArgsForCall(i fake.createApplicationDeploymentMutex.RLock() defer fake.createApplicationDeploymentMutex.RUnlock() argsForCall := fake.createApplicationDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateApplicationDeploymentArgs() []FakeCloudControllerClientCreateApplicationDeploymentArgs { + fake.createApplicationDeploymentMutex.RLock() + defer fake.createApplicationDeploymentMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateApplicationDeploymentArgs, len(fake.createApplicationDeploymentArgsForCall)) + copy(args, fake.createApplicationDeploymentArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateApplicationDeploymentReturns(result1 string, result2 ccv3.Warnings, result3 error) { @@ -3431,10 +4134,7 @@ func (fake *FakeCloudControllerClient) CreateApplicationDeploymentReturnsOnCall( func (fake *FakeCloudControllerClient) CreateApplicationProcessScale(arg1 string, arg2 resources.Process) (resources.Process, ccv3.Warnings, error) { fake.createApplicationProcessScaleMutex.Lock() ret, specificReturn := fake.createApplicationProcessScaleReturnsOnCall[len(fake.createApplicationProcessScaleArgsForCall)] - fake.createApplicationProcessScaleArgsForCall = append(fake.createApplicationProcessScaleArgsForCall, struct { - arg1 string - arg2 resources.Process - }{arg1, arg2}) + fake.createApplicationProcessScaleArgsForCall = append(fake.createApplicationProcessScaleArgsForCall, FakeCloudControllerClientCreateApplicationProcessScaleArgs{arg1, arg2}) stub := fake.CreateApplicationProcessScaleStub fakeReturns := fake.createApplicationProcessScaleReturns fake.recordInvocation("CreateApplicationProcessScale", []interface{}{arg1, arg2}) @@ -3464,7 +4164,15 @@ func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleArgsForCall( fake.createApplicationProcessScaleMutex.RLock() defer fake.createApplicationProcessScaleMutex.RUnlock() argsForCall := fake.createApplicationProcessScaleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleArgs() []FakeCloudControllerClientCreateApplicationProcessScaleArgs { + fake.createApplicationProcessScaleMutex.RLock() + defer fake.createApplicationProcessScaleMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateApplicationProcessScaleArgs, len(fake.createApplicationProcessScaleArgsForCall)) + copy(args, fake.createApplicationProcessScaleArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) { @@ -3499,10 +4207,7 @@ func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturnsOnCal func (fake *FakeCloudControllerClient) CreateApplicationTask(arg1 string, arg2 resources.Task) (resources.Task, ccv3.Warnings, error) { fake.createApplicationTaskMutex.Lock() ret, specificReturn := fake.createApplicationTaskReturnsOnCall[len(fake.createApplicationTaskArgsForCall)] - fake.createApplicationTaskArgsForCall = append(fake.createApplicationTaskArgsForCall, struct { - arg1 string - arg2 resources.Task - }{arg1, arg2}) + fake.createApplicationTaskArgsForCall = append(fake.createApplicationTaskArgsForCall, FakeCloudControllerClientCreateApplicationTaskArgs{arg1, arg2}) stub := fake.CreateApplicationTaskStub fakeReturns := fake.createApplicationTaskReturns fake.recordInvocation("CreateApplicationTask", []interface{}{arg1, arg2}) @@ -3532,7 +4237,15 @@ func (fake *FakeCloudControllerClient) CreateApplicationTaskArgsForCall(i int) ( fake.createApplicationTaskMutex.RLock() defer fake.createApplicationTaskMutex.RUnlock() argsForCall := fake.createApplicationTaskArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) CreateApplicationTaskArgs() []FakeCloudControllerClientCreateApplicationTaskArgs { + fake.createApplicationTaskMutex.RLock() + defer fake.createApplicationTaskMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateApplicationTaskArgs, len(fake.createApplicationTaskArgsForCall)) + copy(args, fake.createApplicationTaskArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateApplicationTaskReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) { @@ -3567,9 +4280,7 @@ func (fake *FakeCloudControllerClient) CreateApplicationTaskReturnsOnCall(i int, func (fake *FakeCloudControllerClient) CreateBuild(arg1 resources.Build) (resources.Build, ccv3.Warnings, error) { fake.createBuildMutex.Lock() ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)] - fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct { - arg1 resources.Build - }{arg1}) + fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, FakeCloudControllerClientCreateBuildArgs{arg1}) stub := fake.CreateBuildStub fakeReturns := fake.createBuildReturns fake.recordInvocation("CreateBuild", []interface{}{arg1}) @@ -3599,7 +4310,15 @@ func (fake *FakeCloudControllerClient) CreateBuildArgsForCall(i int) resources.B fake.createBuildMutex.RLock() defer fake.createBuildMutex.RUnlock() argsForCall := fake.createBuildArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateBuildArgs() []FakeCloudControllerClientCreateBuildArgs { + fake.createBuildMutex.RLock() + defer fake.createBuildMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateBuildArgs, len(fake.createBuildArgsForCall)) + copy(args, fake.createBuildArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) { @@ -3634,9 +4353,7 @@ func (fake *FakeCloudControllerClient) CreateBuildReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) CreateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) { fake.createBuildpackMutex.Lock() ret, specificReturn := fake.createBuildpackReturnsOnCall[len(fake.createBuildpackArgsForCall)] - fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, struct { - arg1 resources.Buildpack - }{arg1}) + fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, FakeCloudControllerClientCreateBuildpackArgs{arg1}) stub := fake.CreateBuildpackStub fakeReturns := fake.createBuildpackReturns fake.recordInvocation("CreateBuildpack", []interface{}{arg1}) @@ -3666,7 +4383,15 @@ func (fake *FakeCloudControllerClient) CreateBuildpackArgsForCall(i int) resourc fake.createBuildpackMutex.RLock() defer fake.createBuildpackMutex.RUnlock() argsForCall := fake.createBuildpackArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateBuildpackArgs() []FakeCloudControllerClientCreateBuildpackArgs { + fake.createBuildpackMutex.RLock() + defer fake.createBuildpackMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateBuildpackArgs, len(fake.createBuildpackArgsForCall)) + copy(args, fake.createBuildpackArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateBuildpackReturns(result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) { @@ -3701,9 +4426,7 @@ func (fake *FakeCloudControllerClient) CreateBuildpackReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) CreateDomain(arg1 resources.Domain) (resources.Domain, ccv3.Warnings, error) { fake.createDomainMutex.Lock() ret, specificReturn := fake.createDomainReturnsOnCall[len(fake.createDomainArgsForCall)] - fake.createDomainArgsForCall = append(fake.createDomainArgsForCall, struct { - arg1 resources.Domain - }{arg1}) + fake.createDomainArgsForCall = append(fake.createDomainArgsForCall, FakeCloudControllerClientCreateDomainArgs{arg1}) stub := fake.CreateDomainStub fakeReturns := fake.createDomainReturns fake.recordInvocation("CreateDomain", []interface{}{arg1}) @@ -3733,7 +4456,15 @@ func (fake *FakeCloudControllerClient) CreateDomainArgsForCall(i int) resources. fake.createDomainMutex.RLock() defer fake.createDomainMutex.RUnlock() argsForCall := fake.createDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateDomainArgs() []FakeCloudControllerClientCreateDomainArgs { + fake.createDomainMutex.RLock() + defer fake.createDomainMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateDomainArgs, len(fake.createDomainArgsForCall)) + copy(args, fake.createDomainArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) { @@ -3768,9 +4499,7 @@ func (fake *FakeCloudControllerClient) CreateDomainReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) CreateDroplet(arg1 string) (resources.Droplet, ccv3.Warnings, error) { fake.createDropletMutex.Lock() ret, specificReturn := fake.createDropletReturnsOnCall[len(fake.createDropletArgsForCall)] - fake.createDropletArgsForCall = append(fake.createDropletArgsForCall, struct { - arg1 string - }{arg1}) + fake.createDropletArgsForCall = append(fake.createDropletArgsForCall, FakeCloudControllerClientCreateDropletArgs{arg1}) stub := fake.CreateDropletStub fakeReturns := fake.createDropletReturns fake.recordInvocation("CreateDroplet", []interface{}{arg1}) @@ -3800,7 +4529,15 @@ func (fake *FakeCloudControllerClient) CreateDropletArgsForCall(i int) string { fake.createDropletMutex.RLock() defer fake.createDropletMutex.RUnlock() argsForCall := fake.createDropletArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateDropletArgs() []FakeCloudControllerClientCreateDropletArgs { + fake.createDropletMutex.RLock() + defer fake.createDropletMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateDropletArgs, len(fake.createDropletArgsForCall)) + copy(args, fake.createDropletArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateDropletReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) { @@ -3835,9 +4572,7 @@ func (fake *FakeCloudControllerClient) CreateDropletReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) CreateIsolationSegment(arg1 resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error) { fake.createIsolationSegmentMutex.Lock() ret, specificReturn := fake.createIsolationSegmentReturnsOnCall[len(fake.createIsolationSegmentArgsForCall)] - fake.createIsolationSegmentArgsForCall = append(fake.createIsolationSegmentArgsForCall, struct { - arg1 resources.IsolationSegment - }{arg1}) + fake.createIsolationSegmentArgsForCall = append(fake.createIsolationSegmentArgsForCall, FakeCloudControllerClientCreateIsolationSegmentArgs{arg1}) stub := fake.CreateIsolationSegmentStub fakeReturns := fake.createIsolationSegmentReturns fake.recordInvocation("CreateIsolationSegment", []interface{}{arg1}) @@ -3867,7 +4602,15 @@ func (fake *FakeCloudControllerClient) CreateIsolationSegmentArgsForCall(i int) fake.createIsolationSegmentMutex.RLock() defer fake.createIsolationSegmentMutex.RUnlock() argsForCall := fake.createIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateIsolationSegmentArgs() []FakeCloudControllerClientCreateIsolationSegmentArgs { + fake.createIsolationSegmentMutex.RLock() + defer fake.createIsolationSegmentMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateIsolationSegmentArgs, len(fake.createIsolationSegmentArgsForCall)) + copy(args, fake.createIsolationSegmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) { @@ -3902,9 +4645,7 @@ func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturnsOnCall(i int func (fake *FakeCloudControllerClient) CreateOrganization(arg1 string) (resources.Organization, ccv3.Warnings, error) { fake.createOrganizationMutex.Lock() ret, specificReturn := fake.createOrganizationReturnsOnCall[len(fake.createOrganizationArgsForCall)] - fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, FakeCloudControllerClientCreateOrganizationArgs{arg1}) stub := fake.CreateOrganizationStub fakeReturns := fake.createOrganizationReturns fake.recordInvocation("CreateOrganization", []interface{}{arg1}) @@ -3934,7 +4675,15 @@ func (fake *FakeCloudControllerClient) CreateOrganizationArgsForCall(i int) stri fake.createOrganizationMutex.RLock() defer fake.createOrganizationMutex.RUnlock() argsForCall := fake.createOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateOrganizationArgs() []FakeCloudControllerClientCreateOrganizationArgs { + fake.createOrganizationMutex.RLock() + defer fake.createOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateOrganizationArgs, len(fake.createOrganizationArgsForCall)) + copy(args, fake.createOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) { @@ -3969,9 +4718,7 @@ func (fake *FakeCloudControllerClient) CreateOrganizationReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) CreateOrganizationQuota(arg1 resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) { fake.createOrganizationQuotaMutex.Lock() ret, specificReturn := fake.createOrganizationQuotaReturnsOnCall[len(fake.createOrganizationQuotaArgsForCall)] - fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, struct { - arg1 resources.OrganizationQuota - }{arg1}) + fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, FakeCloudControllerClientCreateOrganizationQuotaArgs{arg1}) stub := fake.CreateOrganizationQuotaStub fakeReturns := fake.createOrganizationQuotaReturns fake.recordInvocation("CreateOrganizationQuota", []interface{}{arg1}) @@ -4001,7 +4748,15 @@ func (fake *FakeCloudControllerClient) CreateOrganizationQuotaArgsForCall(i int) fake.createOrganizationQuotaMutex.RLock() defer fake.createOrganizationQuotaMutex.RUnlock() argsForCall := fake.createOrganizationQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateOrganizationQuotaArgs() []FakeCloudControllerClientCreateOrganizationQuotaArgs { + fake.createOrganizationQuotaMutex.RLock() + defer fake.createOrganizationQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateOrganizationQuotaArgs, len(fake.createOrganizationQuotaArgsForCall)) + copy(args, fake.createOrganizationQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) { @@ -4036,9 +4791,7 @@ func (fake *FakeCloudControllerClient) CreateOrganizationQuotaReturnsOnCall(i in func (fake *FakeCloudControllerClient) CreatePackage(arg1 resources.Package) (resources.Package, ccv3.Warnings, error) { fake.createPackageMutex.Lock() ret, specificReturn := fake.createPackageReturnsOnCall[len(fake.createPackageArgsForCall)] - fake.createPackageArgsForCall = append(fake.createPackageArgsForCall, struct { - arg1 resources.Package - }{arg1}) + fake.createPackageArgsForCall = append(fake.createPackageArgsForCall, FakeCloudControllerClientCreatePackageArgs{arg1}) stub := fake.CreatePackageStub fakeReturns := fake.createPackageReturns fake.recordInvocation("CreatePackage", []interface{}{arg1}) @@ -4068,7 +4821,15 @@ func (fake *FakeCloudControllerClient) CreatePackageArgsForCall(i int) resources fake.createPackageMutex.RLock() defer fake.createPackageMutex.RUnlock() argsForCall := fake.createPackageArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreatePackageArgs() []FakeCloudControllerClientCreatePackageArgs { + fake.createPackageMutex.RLock() + defer fake.createPackageMutex.RUnlock() + args := make([]FakeCloudControllerClientCreatePackageArgs, len(fake.createPackageArgsForCall)) + copy(args, fake.createPackageArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreatePackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) { @@ -4103,9 +4864,7 @@ func (fake *FakeCloudControllerClient) CreatePackageReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) CreateRole(arg1 resources.Role) (resources.Role, ccv3.Warnings, error) { fake.createRoleMutex.Lock() ret, specificReturn := fake.createRoleReturnsOnCall[len(fake.createRoleArgsForCall)] - fake.createRoleArgsForCall = append(fake.createRoleArgsForCall, struct { - arg1 resources.Role - }{arg1}) + fake.createRoleArgsForCall = append(fake.createRoleArgsForCall, FakeCloudControllerClientCreateRoleArgs{arg1}) stub := fake.CreateRoleStub fakeReturns := fake.createRoleReturns fake.recordInvocation("CreateRole", []interface{}{arg1}) @@ -4135,7 +4894,15 @@ func (fake *FakeCloudControllerClient) CreateRoleArgsForCall(i int) resources.Ro fake.createRoleMutex.RLock() defer fake.createRoleMutex.RUnlock() argsForCall := fake.createRoleArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateRoleArgs() []FakeCloudControllerClientCreateRoleArgs { + fake.createRoleMutex.RLock() + defer fake.createRoleMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateRoleArgs, len(fake.createRoleArgsForCall)) + copy(args, fake.createRoleArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateRoleReturns(result1 resources.Role, result2 ccv3.Warnings, result3 error) { @@ -4170,9 +4937,7 @@ func (fake *FakeCloudControllerClient) CreateRoleReturnsOnCall(i int, result1 re func (fake *FakeCloudControllerClient) CreateRoute(arg1 resources.Route) (resources.Route, ccv3.Warnings, error) { fake.createRouteMutex.Lock() ret, specificReturn := fake.createRouteReturnsOnCall[len(fake.createRouteArgsForCall)] - fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, struct { - arg1 resources.Route - }{arg1}) + fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, FakeCloudControllerClientCreateRouteArgs{arg1}) stub := fake.CreateRouteStub fakeReturns := fake.createRouteReturns fake.recordInvocation("CreateRoute", []interface{}{arg1}) @@ -4202,7 +4967,15 @@ func (fake *FakeCloudControllerClient) CreateRouteArgsForCall(i int) resources.R fake.createRouteMutex.RLock() defer fake.createRouteMutex.RUnlock() argsForCall := fake.createRouteArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateRouteArgs() []FakeCloudControllerClientCreateRouteArgs { + fake.createRouteMutex.RLock() + defer fake.createRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateRouteArgs, len(fake.createRouteArgsForCall)) + copy(args, fake.createRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateRouteReturns(result1 resources.Route, result2 ccv3.Warnings, result3 error) { @@ -4237,9 +5010,7 @@ func (fake *FakeCloudControllerClient) CreateRouteReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) CreateRouteBinding(arg1 resources.RouteBinding) (ccv3.JobURL, ccv3.Warnings, error) { fake.createRouteBindingMutex.Lock() ret, specificReturn := fake.createRouteBindingReturnsOnCall[len(fake.createRouteBindingArgsForCall)] - fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, struct { - arg1 resources.RouteBinding - }{arg1}) + fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, FakeCloudControllerClientCreateRouteBindingArgs{arg1}) stub := fake.CreateRouteBindingStub fakeReturns := fake.createRouteBindingReturns fake.recordInvocation("CreateRouteBinding", []interface{}{arg1}) @@ -4269,7 +5040,15 @@ func (fake *FakeCloudControllerClient) CreateRouteBindingArgsForCall(i int) reso fake.createRouteBindingMutex.RLock() defer fake.createRouteBindingMutex.RUnlock() argsForCall := fake.createRouteBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateRouteBindingArgs() []FakeCloudControllerClientCreateRouteBindingArgs { + fake.createRouteBindingMutex.RLock() + defer fake.createRouteBindingMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateRouteBindingArgs, len(fake.createRouteBindingArgsForCall)) + copy(args, fake.createRouteBindingArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateRouteBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -4304,9 +5083,7 @@ func (fake *FakeCloudControllerClient) CreateRouteBindingReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) CreateRoutePolicy(arg1 resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error) { fake.createRoutePolicyMutex.Lock() ret, specificReturn := fake.createRoutePolicyReturnsOnCall[len(fake.createRoutePolicyArgsForCall)] - fake.createRoutePolicyArgsForCall = append(fake.createRoutePolicyArgsForCall, struct { - arg1 resources.RoutePolicy - }{arg1}) + fake.createRoutePolicyArgsForCall = append(fake.createRoutePolicyArgsForCall, FakeCloudControllerClientCreateRoutePolicyArgs{arg1}) stub := fake.CreateRoutePolicyStub fakeReturns := fake.createRoutePolicyReturns fake.recordInvocation("CreateRoutePolicy", []interface{}{arg1}) @@ -4336,7 +5113,15 @@ func (fake *FakeCloudControllerClient) CreateRoutePolicyArgsForCall(i int) resou fake.createRoutePolicyMutex.RLock() defer fake.createRoutePolicyMutex.RUnlock() argsForCall := fake.createRoutePolicyArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyArgs() []FakeCloudControllerClientCreateRoutePolicyArgs { + fake.createRoutePolicyMutex.RLock() + defer fake.createRoutePolicyMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateRoutePolicyArgs, len(fake.createRoutePolicyArgsForCall)) + copy(args, fake.createRoutePolicyArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateRoutePolicyReturns(result1 resources.RoutePolicy, result2 ccv3.Warnings, result3 error) { @@ -4371,9 +5156,7 @@ func (fake *FakeCloudControllerClient) CreateRoutePolicyReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) CreateSecurityGroup(arg1 resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) { fake.createSecurityGroupMutex.Lock() ret, specificReturn := fake.createSecurityGroupReturnsOnCall[len(fake.createSecurityGroupArgsForCall)] - fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, struct { - arg1 resources.SecurityGroup - }{arg1}) + fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, FakeCloudControllerClientCreateSecurityGroupArgs{arg1}) stub := fake.CreateSecurityGroupStub fakeReturns := fake.createSecurityGroupReturns fake.recordInvocation("CreateSecurityGroup", []interface{}{arg1}) @@ -4403,7 +5186,15 @@ func (fake *FakeCloudControllerClient) CreateSecurityGroupArgsForCall(i int) res fake.createSecurityGroupMutex.RLock() defer fake.createSecurityGroupMutex.RUnlock() argsForCall := fake.createSecurityGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateSecurityGroupArgs() []FakeCloudControllerClientCreateSecurityGroupArgs { + fake.createSecurityGroupMutex.RLock() + defer fake.createSecurityGroupMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateSecurityGroupArgs, len(fake.createSecurityGroupArgsForCall)) + copy(args, fake.createSecurityGroupArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateSecurityGroupReturns(result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) { @@ -4435,12 +5226,83 @@ func (fake *FakeCloudControllerClient) CreateSecurityGroupReturnsOnCall(i int, r }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) CreateServiceAccount(arg1 resources.ServiceAccount) (resources.ServiceAccount, ccv3.Warnings, error) { + fake.createServiceAccountMutex.Lock() + ret, specificReturn := fake.createServiceAccountReturnsOnCall[len(fake.createServiceAccountArgsForCall)] + fake.createServiceAccountArgsForCall = append(fake.createServiceAccountArgsForCall, FakeCloudControllerClientCreateServiceAccountArgs{arg1}) + stub := fake.CreateServiceAccountStub + fakeReturns := fake.createServiceAccountReturns + fake.recordInvocation("CreateServiceAccount", []interface{}{arg1}) + fake.createServiceAccountMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountCallCount() int { + fake.createServiceAccountMutex.RLock() + defer fake.createServiceAccountMutex.RUnlock() + return len(fake.createServiceAccountArgsForCall) +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountCalls(stub func(resources.ServiceAccount) (resources.ServiceAccount, ccv3.Warnings, error)) { + fake.createServiceAccountMutex.Lock() + defer fake.createServiceAccountMutex.Unlock() + fake.CreateServiceAccountStub = stub +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountArgsForCall(i int) resources.ServiceAccount { + fake.createServiceAccountMutex.RLock() + defer fake.createServiceAccountMutex.RUnlock() + argsForCall := fake.createServiceAccountArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountArgs() []FakeCloudControllerClientCreateServiceAccountArgs { + fake.createServiceAccountMutex.RLock() + defer fake.createServiceAccountMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateServiceAccountArgs, len(fake.createServiceAccountArgsForCall)) + copy(args, fake.createServiceAccountArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountReturns(result1 resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.createServiceAccountMutex.Lock() + defer fake.createServiceAccountMutex.Unlock() + fake.CreateServiceAccountStub = nil + fake.createServiceAccountReturns = struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) CreateServiceAccountReturnsOnCall(i int, result1 resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.createServiceAccountMutex.Lock() + defer fake.createServiceAccountMutex.Unlock() + fake.CreateServiceAccountStub = nil + if fake.createServiceAccountReturnsOnCall == nil { + fake.createServiceAccountReturnsOnCall = make(map[int]struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }) + } + fake.createServiceAccountReturnsOnCall[i] = struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) CreateServiceBroker(arg1 resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) { fake.createServiceBrokerMutex.Lock() ret, specificReturn := fake.createServiceBrokerReturnsOnCall[len(fake.createServiceBrokerArgsForCall)] - fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, struct { - arg1 resources.ServiceBroker - }{arg1}) + fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, FakeCloudControllerClientCreateServiceBrokerArgs{arg1}) stub := fake.CreateServiceBrokerStub fakeReturns := fake.createServiceBrokerReturns fake.recordInvocation("CreateServiceBroker", []interface{}{arg1}) @@ -4470,7 +5332,15 @@ func (fake *FakeCloudControllerClient) CreateServiceBrokerArgsForCall(i int) res fake.createServiceBrokerMutex.RLock() defer fake.createServiceBrokerMutex.RUnlock() argsForCall := fake.createServiceBrokerArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateServiceBrokerArgs() []FakeCloudControllerClientCreateServiceBrokerArgs { + fake.createServiceBrokerMutex.RLock() + defer fake.createServiceBrokerMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateServiceBrokerArgs, len(fake.createServiceBrokerArgsForCall)) + copy(args, fake.createServiceBrokerArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -4505,9 +5375,7 @@ func (fake *FakeCloudControllerClient) CreateServiceBrokerReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) CreateServiceCredentialBinding(arg1 resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error) { fake.createServiceCredentialBindingMutex.Lock() ret, specificReturn := fake.createServiceCredentialBindingReturnsOnCall[len(fake.createServiceCredentialBindingArgsForCall)] - fake.createServiceCredentialBindingArgsForCall = append(fake.createServiceCredentialBindingArgsForCall, struct { - arg1 resources.ServiceCredentialBinding - }{arg1}) + fake.createServiceCredentialBindingArgsForCall = append(fake.createServiceCredentialBindingArgsForCall, FakeCloudControllerClientCreateServiceCredentialBindingArgs{arg1}) stub := fake.CreateServiceCredentialBindingStub fakeReturns := fake.createServiceCredentialBindingReturns fake.recordInvocation("CreateServiceCredentialBinding", []interface{}{arg1}) @@ -4537,7 +5405,15 @@ func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingArgsForCall fake.createServiceCredentialBindingMutex.RLock() defer fake.createServiceCredentialBindingMutex.RUnlock() argsForCall := fake.createServiceCredentialBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingArgs() []FakeCloudControllerClientCreateServiceCredentialBindingArgs { + fake.createServiceCredentialBindingMutex.RLock() + defer fake.createServiceCredentialBindingMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateServiceCredentialBindingArgs, len(fake.createServiceCredentialBindingArgsForCall)) + copy(args, fake.createServiceCredentialBindingArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -4572,9 +5448,7 @@ func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingReturnsOnCa func (fake *FakeCloudControllerClient) CreateServiceInstance(arg1 resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) { fake.createServiceInstanceMutex.Lock() ret, specificReturn := fake.createServiceInstanceReturnsOnCall[len(fake.createServiceInstanceArgsForCall)] - fake.createServiceInstanceArgsForCall = append(fake.createServiceInstanceArgsForCall, struct { - arg1 resources.ServiceInstance - }{arg1}) + fake.createServiceInstanceArgsForCall = append(fake.createServiceInstanceArgsForCall, FakeCloudControllerClientCreateServiceInstanceArgs{arg1}) stub := fake.CreateServiceInstanceStub fakeReturns := fake.createServiceInstanceReturns fake.recordInvocation("CreateServiceInstance", []interface{}{arg1}) @@ -4604,7 +5478,15 @@ func (fake *FakeCloudControllerClient) CreateServiceInstanceArgsForCall(i int) r fake.createServiceInstanceMutex.RLock() defer fake.createServiceInstanceMutex.RUnlock() argsForCall := fake.createServiceInstanceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateServiceInstanceArgs() []FakeCloudControllerClientCreateServiceInstanceArgs { + fake.createServiceInstanceMutex.RLock() + defer fake.createServiceInstanceMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateServiceInstanceArgs, len(fake.createServiceInstanceArgsForCall)) + copy(args, fake.createServiceInstanceArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -4639,9 +5521,7 @@ func (fake *FakeCloudControllerClient) CreateServiceInstanceReturnsOnCall(i int, func (fake *FakeCloudControllerClient) CreateSpace(arg1 resources.Space) (resources.Space, ccv3.Warnings, error) { fake.createSpaceMutex.Lock() ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)] - fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct { - arg1 resources.Space - }{arg1}) + fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, FakeCloudControllerClientCreateSpaceArgs{arg1}) stub := fake.CreateSpaceStub fakeReturns := fake.createSpaceReturns fake.recordInvocation("CreateSpace", []interface{}{arg1}) @@ -4671,7 +5551,15 @@ func (fake *FakeCloudControllerClient) CreateSpaceArgsForCall(i int) resources.S fake.createSpaceMutex.RLock() defer fake.createSpaceMutex.RUnlock() argsForCall := fake.createSpaceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateSpaceArgs() []FakeCloudControllerClientCreateSpaceArgs { + fake.createSpaceMutex.RLock() + defer fake.createSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateSpaceArgs, len(fake.createSpaceArgsForCall)) + copy(args, fake.createSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateSpaceReturns(result1 resources.Space, result2 ccv3.Warnings, result3 error) { @@ -4706,9 +5594,7 @@ func (fake *FakeCloudControllerClient) CreateSpaceReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) CreateSpaceQuota(arg1 resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) { fake.createSpaceQuotaMutex.Lock() ret, specificReturn := fake.createSpaceQuotaReturnsOnCall[len(fake.createSpaceQuotaArgsForCall)] - fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, struct { - arg1 resources.SpaceQuota - }{arg1}) + fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, FakeCloudControllerClientCreateSpaceQuotaArgs{arg1}) stub := fake.CreateSpaceQuotaStub fakeReturns := fake.createSpaceQuotaReturns fake.recordInvocation("CreateSpaceQuota", []interface{}{arg1}) @@ -4738,7 +5624,15 @@ func (fake *FakeCloudControllerClient) CreateSpaceQuotaArgsForCall(i int) resour fake.createSpaceQuotaMutex.RLock() defer fake.createSpaceQuotaMutex.RUnlock() argsForCall := fake.createSpaceQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateSpaceQuotaArgs() []FakeCloudControllerClientCreateSpaceQuotaArgs { + fake.createSpaceQuotaMutex.RLock() + defer fake.createSpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateSpaceQuotaArgs, len(fake.createSpaceQuotaArgsForCall)) + copy(args, fake.createSpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) { @@ -4773,9 +5667,7 @@ func (fake *FakeCloudControllerClient) CreateSpaceQuotaReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) CreateUser(arg1 string) (resources.User, ccv3.Warnings, error) { fake.createUserMutex.Lock() ret, specificReturn := fake.createUserReturnsOnCall[len(fake.createUserArgsForCall)] - fake.createUserArgsForCall = append(fake.createUserArgsForCall, struct { - arg1 string - }{arg1}) + fake.createUserArgsForCall = append(fake.createUserArgsForCall, FakeCloudControllerClientCreateUserArgs{arg1}) stub := fake.CreateUserStub fakeReturns := fake.createUserReturns fake.recordInvocation("CreateUser", []interface{}{arg1}) @@ -4805,7 +5697,15 @@ func (fake *FakeCloudControllerClient) CreateUserArgsForCall(i int) string { fake.createUserMutex.RLock() defer fake.createUserMutex.RUnlock() argsForCall := fake.createUserArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) CreateUserArgs() []FakeCloudControllerClientCreateUserArgs { + fake.createUserMutex.RLock() + defer fake.createUserMutex.RUnlock() + args := make([]FakeCloudControllerClientCreateUserArgs, len(fake.createUserArgsForCall)) + copy(args, fake.createUserArgsForCall) + return args } func (fake *FakeCloudControllerClient) CreateUserReturns(result1 resources.User, result2 ccv3.Warnings, result3 error) { @@ -4840,9 +5740,7 @@ func (fake *FakeCloudControllerClient) CreateUserReturnsOnCall(i int, result1 re func (fake *FakeCloudControllerClient) DeleteApplication(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteApplicationMutex.Lock() ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)] - fake.deleteApplicationArgsForCall = append(fake.deleteApplicationArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteApplicationArgsForCall = append(fake.deleteApplicationArgsForCall, FakeCloudControllerClientDeleteApplicationArgs{arg1}) stub := fake.DeleteApplicationStub fakeReturns := fake.deleteApplicationReturns fake.recordInvocation("DeleteApplication", []interface{}{arg1}) @@ -4872,7 +5770,15 @@ func (fake *FakeCloudControllerClient) DeleteApplicationArgsForCall(i int) strin fake.deleteApplicationMutex.RLock() defer fake.deleteApplicationMutex.RUnlock() argsForCall := fake.deleteApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteApplicationArgs() []FakeCloudControllerClientDeleteApplicationArgs { + fake.deleteApplicationMutex.RLock() + defer fake.deleteApplicationMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteApplicationArgs, len(fake.deleteApplicationArgsForCall)) + copy(args, fake.deleteApplicationArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteApplicationReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -4907,11 +5813,7 @@ func (fake *FakeCloudControllerClient) DeleteApplicationReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstance(arg1 string, arg2 string, arg3 int) (ccv3.Warnings, error) { fake.deleteApplicationProcessInstanceMutex.Lock() ret, specificReturn := fake.deleteApplicationProcessInstanceReturnsOnCall[len(fake.deleteApplicationProcessInstanceArgsForCall)] - fake.deleteApplicationProcessInstanceArgsForCall = append(fake.deleteApplicationProcessInstanceArgsForCall, struct { - arg1 string - arg2 string - arg3 int - }{arg1, arg2, arg3}) + fake.deleteApplicationProcessInstanceArgsForCall = append(fake.deleteApplicationProcessInstanceArgsForCall, FakeCloudControllerClientDeleteApplicationProcessInstanceArgs{arg1, arg2, arg3}) stub := fake.DeleteApplicationProcessInstanceStub fakeReturns := fake.deleteApplicationProcessInstanceReturns fake.recordInvocation("DeleteApplicationProcessInstance", []interface{}{arg1, arg2, arg3}) @@ -4941,7 +5843,15 @@ func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceArgsForCa fake.deleteApplicationProcessInstanceMutex.RLock() defer fake.deleteApplicationProcessInstanceMutex.RUnlock() argsForCall := fake.deleteApplicationProcessInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceArgs() []FakeCloudControllerClientDeleteApplicationProcessInstanceArgs { + fake.deleteApplicationProcessInstanceMutex.RLock() + defer fake.deleteApplicationProcessInstanceMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteApplicationProcessInstanceArgs, len(fake.deleteApplicationProcessInstanceArgsForCall)) + copy(args, fake.deleteApplicationProcessInstanceArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturns(result1 ccv3.Warnings, result2 error) { @@ -4973,9 +5883,7 @@ func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturnsOn func (fake *FakeCloudControllerClient) DeleteBuildpack(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteBuildpackMutex.Lock() ret, specificReturn := fake.deleteBuildpackReturnsOnCall[len(fake.deleteBuildpackArgsForCall)] - fake.deleteBuildpackArgsForCall = append(fake.deleteBuildpackArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteBuildpackArgsForCall = append(fake.deleteBuildpackArgsForCall, FakeCloudControllerClientDeleteBuildpackArgs{arg1}) stub := fake.DeleteBuildpackStub fakeReturns := fake.deleteBuildpackReturns fake.recordInvocation("DeleteBuildpack", []interface{}{arg1}) @@ -5005,7 +5913,15 @@ func (fake *FakeCloudControllerClient) DeleteBuildpackArgsForCall(i int) string fake.deleteBuildpackMutex.RLock() defer fake.deleteBuildpackMutex.RUnlock() argsForCall := fake.deleteBuildpackArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteBuildpackArgs() []FakeCloudControllerClientDeleteBuildpackArgs { + fake.deleteBuildpackMutex.RLock() + defer fake.deleteBuildpackMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteBuildpackArgs, len(fake.deleteBuildpackArgsForCall)) + copy(args, fake.deleteBuildpackArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteBuildpackReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5040,9 +5956,7 @@ func (fake *FakeCloudControllerClient) DeleteBuildpackReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) DeleteDomain(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteDomainMutex.Lock() ret, specificReturn := fake.deleteDomainReturnsOnCall[len(fake.deleteDomainArgsForCall)] - fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, FakeCloudControllerClientDeleteDomainArgs{arg1}) stub := fake.DeleteDomainStub fakeReturns := fake.deleteDomainReturns fake.recordInvocation("DeleteDomain", []interface{}{arg1}) @@ -5072,7 +5986,15 @@ func (fake *FakeCloudControllerClient) DeleteDomainArgsForCall(i int) string { fake.deleteDomainMutex.RLock() defer fake.deleteDomainMutex.RUnlock() argsForCall := fake.deleteDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteDomainArgs() []FakeCloudControllerClientDeleteDomainArgs { + fake.deleteDomainMutex.RLock() + defer fake.deleteDomainMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteDomainArgs, len(fake.deleteDomainArgsForCall)) + copy(args, fake.deleteDomainArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteDomainReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5107,9 +6029,7 @@ func (fake *FakeCloudControllerClient) DeleteDomainReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) DeleteIsolationSegment(arg1 string) (ccv3.Warnings, error) { fake.deleteIsolationSegmentMutex.Lock() ret, specificReturn := fake.deleteIsolationSegmentReturnsOnCall[len(fake.deleteIsolationSegmentArgsForCall)] - fake.deleteIsolationSegmentArgsForCall = append(fake.deleteIsolationSegmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteIsolationSegmentArgsForCall = append(fake.deleteIsolationSegmentArgsForCall, FakeCloudControllerClientDeleteIsolationSegmentArgs{arg1}) stub := fake.DeleteIsolationSegmentStub fakeReturns := fake.deleteIsolationSegmentReturns fake.recordInvocation("DeleteIsolationSegment", []interface{}{arg1}) @@ -5139,7 +6059,15 @@ func (fake *FakeCloudControllerClient) DeleteIsolationSegmentArgsForCall(i int) fake.deleteIsolationSegmentMutex.RLock() defer fake.deleteIsolationSegmentMutex.RUnlock() argsForCall := fake.deleteIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteIsolationSegmentArgs() []FakeCloudControllerClientDeleteIsolationSegmentArgs { + fake.deleteIsolationSegmentMutex.RLock() + defer fake.deleteIsolationSegmentMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteIsolationSegmentArgs, len(fake.deleteIsolationSegmentArgsForCall)) + copy(args, fake.deleteIsolationSegmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturns(result1 ccv3.Warnings, result2 error) { @@ -5171,10 +6099,7 @@ func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturnsOnCall(i int func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganization(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.deleteIsolationSegmentOrganizationMutex.Lock() ret, specificReturn := fake.deleteIsolationSegmentOrganizationReturnsOnCall[len(fake.deleteIsolationSegmentOrganizationArgsForCall)] - fake.deleteIsolationSegmentOrganizationArgsForCall = append(fake.deleteIsolationSegmentOrganizationArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteIsolationSegmentOrganizationArgsForCall = append(fake.deleteIsolationSegmentOrganizationArgsForCall, FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs{arg1, arg2}) stub := fake.DeleteIsolationSegmentOrganizationStub fakeReturns := fake.deleteIsolationSegmentOrganizationReturns fake.recordInvocation("DeleteIsolationSegmentOrganization", []interface{}{arg1, arg2}) @@ -5204,7 +6129,15 @@ func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationArgsFor fake.deleteIsolationSegmentOrganizationMutex.RLock() defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock() argsForCall := fake.deleteIsolationSegmentOrganizationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationArgs() []FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs { + fake.deleteIsolationSegmentOrganizationMutex.RLock() + defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteIsolationSegmentOrganizationArgs, len(fake.deleteIsolationSegmentOrganizationArgsForCall)) + copy(args, fake.deleteIsolationSegmentOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturns(result1 ccv3.Warnings, result2 error) { @@ -5236,9 +6169,7 @@ func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturns func (fake *FakeCloudControllerClient) DeleteOrganization(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteOrganizationMutex.Lock() ret, specificReturn := fake.deleteOrganizationReturnsOnCall[len(fake.deleteOrganizationArgsForCall)] - fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, FakeCloudControllerClientDeleteOrganizationArgs{arg1}) stub := fake.DeleteOrganizationStub fakeReturns := fake.deleteOrganizationReturns fake.recordInvocation("DeleteOrganization", []interface{}{arg1}) @@ -5268,7 +6199,15 @@ func (fake *FakeCloudControllerClient) DeleteOrganizationArgsForCall(i int) stri fake.deleteOrganizationMutex.RLock() defer fake.deleteOrganizationMutex.RUnlock() argsForCall := fake.deleteOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteOrganizationArgs() []FakeCloudControllerClientDeleteOrganizationArgs { + fake.deleteOrganizationMutex.RLock() + defer fake.deleteOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteOrganizationArgs, len(fake.deleteOrganizationArgsForCall)) + copy(args, fake.deleteOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteOrganizationReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5303,9 +6242,7 @@ func (fake *FakeCloudControllerClient) DeleteOrganizationReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) DeleteOrganizationQuota(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteOrganizationQuotaMutex.Lock() ret, specificReturn := fake.deleteOrganizationQuotaReturnsOnCall[len(fake.deleteOrganizationQuotaArgsForCall)] - fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, FakeCloudControllerClientDeleteOrganizationQuotaArgs{arg1}) stub := fake.DeleteOrganizationQuotaStub fakeReturns := fake.deleteOrganizationQuotaReturns fake.recordInvocation("DeleteOrganizationQuota", []interface{}{arg1}) @@ -5335,7 +6272,15 @@ func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaArgsForCall(i int) fake.deleteOrganizationQuotaMutex.RLock() defer fake.deleteOrganizationQuotaMutex.RUnlock() argsForCall := fake.deleteOrganizationQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaArgs() []FakeCloudControllerClientDeleteOrganizationQuotaArgs { + fake.deleteOrganizationQuotaMutex.RLock() + defer fake.deleteOrganizationQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteOrganizationQuotaArgs, len(fake.deleteOrganizationQuotaArgsForCall)) + copy(args, fake.deleteOrganizationQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5370,9 +6315,7 @@ func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaReturnsOnCall(i in func (fake *FakeCloudControllerClient) DeleteOrphanedRoutes(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteOrphanedRoutesMutex.Lock() ret, specificReturn := fake.deleteOrphanedRoutesReturnsOnCall[len(fake.deleteOrphanedRoutesArgsForCall)] - fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, FakeCloudControllerClientDeleteOrphanedRoutesArgs{arg1}) stub := fake.DeleteOrphanedRoutesStub fakeReturns := fake.deleteOrphanedRoutesReturns fake.recordInvocation("DeleteOrphanedRoutes", []interface{}{arg1}) @@ -5402,7 +6345,15 @@ func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesArgsForCall(i int) st fake.deleteOrphanedRoutesMutex.RLock() defer fake.deleteOrphanedRoutesMutex.RUnlock() argsForCall := fake.deleteOrphanedRoutesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesArgs() []FakeCloudControllerClientDeleteOrphanedRoutesArgs { + fake.deleteOrphanedRoutesMutex.RLock() + defer fake.deleteOrphanedRoutesMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteOrphanedRoutesArgs, len(fake.deleteOrphanedRoutesArgsForCall)) + copy(args, fake.deleteOrphanedRoutesArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5437,9 +6388,7 @@ func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesReturnsOnCall(i int, func (fake *FakeCloudControllerClient) DeleteRole(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteRoleMutex.Lock() ret, specificReturn := fake.deleteRoleReturnsOnCall[len(fake.deleteRoleArgsForCall)] - fake.deleteRoleArgsForCall = append(fake.deleteRoleArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteRoleArgsForCall = append(fake.deleteRoleArgsForCall, FakeCloudControllerClientDeleteRoleArgs{arg1}) stub := fake.DeleteRoleStub fakeReturns := fake.deleteRoleReturns fake.recordInvocation("DeleteRole", []interface{}{arg1}) @@ -5469,7 +6418,15 @@ func (fake *FakeCloudControllerClient) DeleteRoleArgsForCall(i int) string { fake.deleteRoleMutex.RLock() defer fake.deleteRoleMutex.RUnlock() argsForCall := fake.deleteRoleArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteRoleArgs() []FakeCloudControllerClientDeleteRoleArgs { + fake.deleteRoleMutex.RLock() + defer fake.deleteRoleMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteRoleArgs, len(fake.deleteRoleArgsForCall)) + copy(args, fake.deleteRoleArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteRoleReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5504,9 +6461,7 @@ func (fake *FakeCloudControllerClient) DeleteRoleReturnsOnCall(i int, result1 cc func (fake *FakeCloudControllerClient) DeleteRoute(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteRouteMutex.Lock() ret, specificReturn := fake.deleteRouteReturnsOnCall[len(fake.deleteRouteArgsForCall)] - fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, FakeCloudControllerClientDeleteRouteArgs{arg1}) stub := fake.DeleteRouteStub fakeReturns := fake.deleteRouteReturns fake.recordInvocation("DeleteRoute", []interface{}{arg1}) @@ -5536,7 +6491,15 @@ func (fake *FakeCloudControllerClient) DeleteRouteArgsForCall(i int) string { fake.deleteRouteMutex.RLock() defer fake.deleteRouteMutex.RUnlock() argsForCall := fake.deleteRouteArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteRouteArgs() []FakeCloudControllerClientDeleteRouteArgs { + fake.deleteRouteMutex.RLock() + defer fake.deleteRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteRouteArgs, len(fake.deleteRouteArgsForCall)) + copy(args, fake.deleteRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteRouteReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5571,9 +6534,7 @@ func (fake *FakeCloudControllerClient) DeleteRouteReturnsOnCall(i int, result1 c func (fake *FakeCloudControllerClient) DeleteRouteBinding(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteRouteBindingMutex.Lock() ret, specificReturn := fake.deleteRouteBindingReturnsOnCall[len(fake.deleteRouteBindingArgsForCall)] - fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, FakeCloudControllerClientDeleteRouteBindingArgs{arg1}) stub := fake.DeleteRouteBindingStub fakeReturns := fake.deleteRouteBindingReturns fake.recordInvocation("DeleteRouteBinding", []interface{}{arg1}) @@ -5603,7 +6564,15 @@ func (fake *FakeCloudControllerClient) DeleteRouteBindingArgsForCall(i int) stri fake.deleteRouteBindingMutex.RLock() defer fake.deleteRouteBindingMutex.RUnlock() argsForCall := fake.deleteRouteBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteRouteBindingArgs() []FakeCloudControllerClientDeleteRouteBindingArgs { + fake.deleteRouteBindingMutex.RLock() + defer fake.deleteRouteBindingMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteRouteBindingArgs, len(fake.deleteRouteBindingArgsForCall)) + copy(args, fake.deleteRouteBindingArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteRouteBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5638,9 +6607,7 @@ func (fake *FakeCloudControllerClient) DeleteRouteBindingReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) DeleteRoutePolicy(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteRoutePolicyMutex.Lock() ret, specificReturn := fake.deleteRoutePolicyReturnsOnCall[len(fake.deleteRoutePolicyArgsForCall)] - fake.deleteRoutePolicyArgsForCall = append(fake.deleteRoutePolicyArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteRoutePolicyArgsForCall = append(fake.deleteRoutePolicyArgsForCall, FakeCloudControllerClientDeleteRoutePolicyArgs{arg1}) stub := fake.DeleteRoutePolicyStub fakeReturns := fake.deleteRoutePolicyReturns fake.recordInvocation("DeleteRoutePolicy", []interface{}{arg1}) @@ -5670,7 +6637,15 @@ func (fake *FakeCloudControllerClient) DeleteRoutePolicyArgsForCall(i int) strin fake.deleteRoutePolicyMutex.RLock() defer fake.deleteRoutePolicyMutex.RUnlock() argsForCall := fake.deleteRoutePolicyArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyArgs() []FakeCloudControllerClientDeleteRoutePolicyArgs { + fake.deleteRoutePolicyMutex.RLock() + defer fake.deleteRoutePolicyMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteRoutePolicyArgs, len(fake.deleteRoutePolicyArgsForCall)) + copy(args, fake.deleteRoutePolicyArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteRoutePolicyReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5705,9 +6680,7 @@ func (fake *FakeCloudControllerClient) DeleteRoutePolicyReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) DeleteSecurityGroup(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteSecurityGroupMutex.Lock() ret, specificReturn := fake.deleteSecurityGroupReturnsOnCall[len(fake.deleteSecurityGroupArgsForCall)] - fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, FakeCloudControllerClientDeleteSecurityGroupArgs{arg1}) stub := fake.DeleteSecurityGroupStub fakeReturns := fake.deleteSecurityGroupReturns fake.recordInvocation("DeleteSecurityGroup", []interface{}{arg1}) @@ -5737,7 +6710,15 @@ func (fake *FakeCloudControllerClient) DeleteSecurityGroupArgsForCall(i int) str fake.deleteSecurityGroupMutex.RLock() defer fake.deleteSecurityGroupMutex.RUnlock() argsForCall := fake.deleteSecurityGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteSecurityGroupArgs() []FakeCloudControllerClientDeleteSecurityGroupArgs { + fake.deleteSecurityGroupMutex.RLock() + defer fake.deleteSecurityGroupMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteSecurityGroupArgs, len(fake.deleteSecurityGroupArgsForCall)) + copy(args, fake.deleteSecurityGroupArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteSecurityGroupReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5769,12 +6750,83 @@ func (fake *FakeCloudControllerClient) DeleteSecurityGroupReturnsOnCall(i int, r }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) DeleteServiceAccount(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { + fake.deleteServiceAccountMutex.Lock() + ret, specificReturn := fake.deleteServiceAccountReturnsOnCall[len(fake.deleteServiceAccountArgsForCall)] + fake.deleteServiceAccountArgsForCall = append(fake.deleteServiceAccountArgsForCall, FakeCloudControllerClientDeleteServiceAccountArgs{arg1}) + stub := fake.DeleteServiceAccountStub + fakeReturns := fake.deleteServiceAccountReturns + fake.recordInvocation("DeleteServiceAccount", []interface{}{arg1}) + fake.deleteServiceAccountMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountCallCount() int { + fake.deleteServiceAccountMutex.RLock() + defer fake.deleteServiceAccountMutex.RUnlock() + return len(fake.deleteServiceAccountArgsForCall) +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) { + fake.deleteServiceAccountMutex.Lock() + defer fake.deleteServiceAccountMutex.Unlock() + fake.DeleteServiceAccountStub = stub +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountArgsForCall(i int) string { + fake.deleteServiceAccountMutex.RLock() + defer fake.deleteServiceAccountMutex.RUnlock() + argsForCall := fake.deleteServiceAccountArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountArgs() []FakeCloudControllerClientDeleteServiceAccountArgs { + fake.deleteServiceAccountMutex.RLock() + defer fake.deleteServiceAccountMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteServiceAccountArgs, len(fake.deleteServiceAccountArgsForCall)) + copy(args, fake.deleteServiceAccountArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteServiceAccountMutex.Lock() + defer fake.deleteServiceAccountMutex.Unlock() + fake.DeleteServiceAccountStub = nil + fake.deleteServiceAccountReturns = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) DeleteServiceAccountReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteServiceAccountMutex.Lock() + defer fake.deleteServiceAccountMutex.Unlock() + fake.DeleteServiceAccountStub = nil + if fake.deleteServiceAccountReturnsOnCall == nil { + fake.deleteServiceAccountReturnsOnCall = make(map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }) + } + fake.deleteServiceAccountReturnsOnCall[i] = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) DeleteServiceBroker(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteServiceBrokerMutex.Lock() ret, specificReturn := fake.deleteServiceBrokerReturnsOnCall[len(fake.deleteServiceBrokerArgsForCall)] - fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, FakeCloudControllerClientDeleteServiceBrokerArgs{arg1}) stub := fake.DeleteServiceBrokerStub fakeReturns := fake.deleteServiceBrokerReturns fake.recordInvocation("DeleteServiceBroker", []interface{}{arg1}) @@ -5804,7 +6856,15 @@ func (fake *FakeCloudControllerClient) DeleteServiceBrokerArgsForCall(i int) str fake.deleteServiceBrokerMutex.RLock() defer fake.deleteServiceBrokerMutex.RUnlock() argsForCall := fake.deleteServiceBrokerArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteServiceBrokerArgs() []FakeCloudControllerClientDeleteServiceBrokerArgs { + fake.deleteServiceBrokerMutex.RLock() + defer fake.deleteServiceBrokerMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteServiceBrokerArgs, len(fake.deleteServiceBrokerArgsForCall)) + copy(args, fake.deleteServiceBrokerArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5839,9 +6899,7 @@ func (fake *FakeCloudControllerClient) DeleteServiceBrokerReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) DeleteServiceCredentialBinding(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteServiceCredentialBindingMutex.Lock() ret, specificReturn := fake.deleteServiceCredentialBindingReturnsOnCall[len(fake.deleteServiceCredentialBindingArgsForCall)] - fake.deleteServiceCredentialBindingArgsForCall = append(fake.deleteServiceCredentialBindingArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteServiceCredentialBindingArgsForCall = append(fake.deleteServiceCredentialBindingArgsForCall, FakeCloudControllerClientDeleteServiceCredentialBindingArgs{arg1}) stub := fake.DeleteServiceCredentialBindingStub fakeReturns := fake.deleteServiceCredentialBindingReturns fake.recordInvocation("DeleteServiceCredentialBinding", []interface{}{arg1}) @@ -5871,7 +6929,15 @@ func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingArgsForCall fake.deleteServiceCredentialBindingMutex.RLock() defer fake.deleteServiceCredentialBindingMutex.RUnlock() argsForCall := fake.deleteServiceCredentialBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingArgs() []FakeCloudControllerClientDeleteServiceCredentialBindingArgs { + fake.deleteServiceCredentialBindingMutex.RLock() + defer fake.deleteServiceCredentialBindingMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteServiceCredentialBindingArgs, len(fake.deleteServiceCredentialBindingArgsForCall)) + copy(args, fake.deleteServiceCredentialBindingArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5904,15 +6970,17 @@ func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingReturnsOnCa } func (fake *FakeCloudControllerClient) DeleteServiceInstance(arg1 string, arg2 ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.deleteServiceInstanceMutex.Lock() ret, specificReturn := fake.deleteServiceInstanceReturnsOnCall[len(fake.deleteServiceInstanceArgsForCall)] - fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, FakeCloudControllerClientDeleteServiceInstanceArgs{arg1, arg2Copy}) stub := fake.DeleteServiceInstanceStub fakeReturns := fake.deleteServiceInstanceReturns - fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2}) + fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2Copy}) fake.deleteServiceInstanceMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -5939,7 +7007,15 @@ func (fake *FakeCloudControllerClient) DeleteServiceInstanceArgsForCall(i int) ( fake.deleteServiceInstanceMutex.RLock() defer fake.deleteServiceInstanceMutex.RUnlock() argsForCall := fake.deleteServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) DeleteServiceInstanceArgs() []FakeCloudControllerClientDeleteServiceInstanceArgs { + fake.deleteServiceInstanceMutex.RLock() + defer fake.deleteServiceInstanceMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteServiceInstanceArgs, len(fake.deleteServiceInstanceArgsForCall)) + copy(args, fake.deleteServiceInstanceArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -5974,10 +7050,7 @@ func (fake *FakeCloudControllerClient) DeleteServiceInstanceReturnsOnCall(i int, func (fake *FakeCloudControllerClient) DeleteServicePlanVisibility(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.deleteServicePlanVisibilityMutex.Lock() ret, specificReturn := fake.deleteServicePlanVisibilityReturnsOnCall[len(fake.deleteServicePlanVisibilityArgsForCall)] - fake.deleteServicePlanVisibilityArgsForCall = append(fake.deleteServicePlanVisibilityArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteServicePlanVisibilityArgsForCall = append(fake.deleteServicePlanVisibilityArgsForCall, FakeCloudControllerClientDeleteServicePlanVisibilityArgs{arg1, arg2}) stub := fake.DeleteServicePlanVisibilityStub fakeReturns := fake.deleteServicePlanVisibilityReturns fake.recordInvocation("DeleteServicePlanVisibility", []interface{}{arg1, arg2}) @@ -6007,7 +7080,15 @@ func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityArgsForCall(i fake.deleteServicePlanVisibilityMutex.RLock() defer fake.deleteServicePlanVisibilityMutex.RUnlock() argsForCall := fake.deleteServicePlanVisibilityArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityArgs() []FakeCloudControllerClientDeleteServicePlanVisibilityArgs { + fake.deleteServicePlanVisibilityMutex.RLock() + defer fake.deleteServicePlanVisibilityMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteServicePlanVisibilityArgs, len(fake.deleteServicePlanVisibilityArgsForCall)) + copy(args, fake.deleteServicePlanVisibilityArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturns(result1 ccv3.Warnings, result2 error) { @@ -6039,9 +7120,7 @@ func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturnsOnCall( func (fake *FakeCloudControllerClient) DeleteSpace(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteSpaceMutex.Lock() ret, specificReturn := fake.deleteSpaceReturnsOnCall[len(fake.deleteSpaceArgsForCall)] - fake.deleteSpaceArgsForCall = append(fake.deleteSpaceArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteSpaceArgsForCall = append(fake.deleteSpaceArgsForCall, FakeCloudControllerClientDeleteSpaceArgs{arg1}) stub := fake.DeleteSpaceStub fakeReturns := fake.deleteSpaceReturns fake.recordInvocation("DeleteSpace", []interface{}{arg1}) @@ -6071,7 +7150,15 @@ func (fake *FakeCloudControllerClient) DeleteSpaceArgsForCall(i int) string { fake.deleteSpaceMutex.RLock() defer fake.deleteSpaceMutex.RUnlock() argsForCall := fake.deleteSpaceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteSpaceArgs() []FakeCloudControllerClientDeleteSpaceArgs { + fake.deleteSpaceMutex.RLock() + defer fake.deleteSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteSpaceArgs, len(fake.deleteSpaceArgsForCall)) + copy(args, fake.deleteSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteSpaceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -6106,9 +7193,7 @@ func (fake *FakeCloudControllerClient) DeleteSpaceReturnsOnCall(i int, result1 c func (fake *FakeCloudControllerClient) DeleteSpaceQuota(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteSpaceQuotaMutex.Lock() ret, specificReturn := fake.deleteSpaceQuotaReturnsOnCall[len(fake.deleteSpaceQuotaArgsForCall)] - fake.deleteSpaceQuotaArgsForCall = append(fake.deleteSpaceQuotaArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteSpaceQuotaArgsForCall = append(fake.deleteSpaceQuotaArgsForCall, FakeCloudControllerClientDeleteSpaceQuotaArgs{arg1}) stub := fake.DeleteSpaceQuotaStub fakeReturns := fake.deleteSpaceQuotaReturns fake.recordInvocation("DeleteSpaceQuota", []interface{}{arg1}) @@ -6138,7 +7223,15 @@ func (fake *FakeCloudControllerClient) DeleteSpaceQuotaArgsForCall(i int) string fake.deleteSpaceQuotaMutex.RLock() defer fake.deleteSpaceQuotaMutex.RUnlock() argsForCall := fake.deleteSpaceQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteSpaceQuotaArgs() []FakeCloudControllerClientDeleteSpaceQuotaArgs { + fake.deleteSpaceQuotaMutex.RLock() + defer fake.deleteSpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteSpaceQuotaArgs, len(fake.deleteSpaceQuotaArgsForCall)) + copy(args, fake.deleteSpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteSpaceQuotaReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -6173,9 +7266,7 @@ func (fake *FakeCloudControllerClient) DeleteSpaceQuotaReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) DeleteUser(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteUserMutex.Lock() ret, specificReturn := fake.deleteUserReturnsOnCall[len(fake.deleteUserArgsForCall)] - fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, FakeCloudControllerClientDeleteUserArgs{arg1}) stub := fake.DeleteUserStub fakeReturns := fake.deleteUserReturns fake.recordInvocation("DeleteUser", []interface{}{arg1}) @@ -6205,7 +7296,15 @@ func (fake *FakeCloudControllerClient) DeleteUserArgsForCall(i int) string { fake.deleteUserMutex.RLock() defer fake.deleteUserMutex.RUnlock() argsForCall := fake.deleteUserArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DeleteUserArgs() []FakeCloudControllerClientDeleteUserArgs { + fake.deleteUserMutex.RLock() + defer fake.deleteUserMutex.RUnlock() + args := make([]FakeCloudControllerClientDeleteUserArgs, len(fake.deleteUserArgsForCall)) + copy(args, fake.deleteUserArgsForCall) + return args } func (fake *FakeCloudControllerClient) DeleteUserReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -6240,9 +7339,7 @@ func (fake *FakeCloudControllerClient) DeleteUserReturnsOnCall(i int, result1 cc func (fake *FakeCloudControllerClient) DownloadDroplet(arg1 string) ([]byte, ccv3.Warnings, error) { fake.downloadDropletMutex.Lock() ret, specificReturn := fake.downloadDropletReturnsOnCall[len(fake.downloadDropletArgsForCall)] - fake.downloadDropletArgsForCall = append(fake.downloadDropletArgsForCall, struct { - arg1 string - }{arg1}) + fake.downloadDropletArgsForCall = append(fake.downloadDropletArgsForCall, FakeCloudControllerClientDownloadDropletArgs{arg1}) stub := fake.DownloadDropletStub fakeReturns := fake.downloadDropletReturns fake.recordInvocation("DownloadDroplet", []interface{}{arg1}) @@ -6272,7 +7369,15 @@ func (fake *FakeCloudControllerClient) DownloadDropletArgsForCall(i int) string fake.downloadDropletMutex.RLock() defer fake.downloadDropletMutex.RUnlock() argsForCall := fake.downloadDropletArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) DownloadDropletArgs() []FakeCloudControllerClientDownloadDropletArgs { + fake.downloadDropletMutex.RLock() + defer fake.downloadDropletMutex.RUnlock() + args := make([]FakeCloudControllerClientDownloadDropletArgs, len(fake.downloadDropletArgsForCall)) + copy(args, fake.downloadDropletArgsForCall) + return args } func (fake *FakeCloudControllerClient) DownloadDropletReturns(result1 []byte, result2 ccv3.Warnings, result3 error) { @@ -6312,10 +7417,7 @@ func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizations(ar } fake.entitleIsolationSegmentToOrganizationsMutex.Lock() ret, specificReturn := fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)] - fake.entitleIsolationSegmentToOrganizationsArgsForCall = append(fake.entitleIsolationSegmentToOrganizationsArgsForCall, struct { - arg1 string - arg2 []string - }{arg1, arg2Copy}) + fake.entitleIsolationSegmentToOrganizationsArgsForCall = append(fake.entitleIsolationSegmentToOrganizationsArgsForCall, FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs{arg1, arg2Copy}) stub := fake.EntitleIsolationSegmentToOrganizationsStub fakeReturns := fake.entitleIsolationSegmentToOrganizationsReturns fake.recordInvocation("EntitleIsolationSegmentToOrganizations", []interface{}{arg1, arg2Copy}) @@ -6345,7 +7447,15 @@ func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsArg fake.entitleIsolationSegmentToOrganizationsMutex.RLock() defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock() argsForCall := fake.entitleIsolationSegmentToOrganizationsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsArgs() []FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs { + fake.entitleIsolationSegmentToOrganizationsMutex.RLock() + defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock() + args := make([]FakeCloudControllerClientEntitleIsolationSegmentToOrganizationsArgs, len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)) + copy(args, fake.entitleIsolationSegmentToOrganizationsArgsForCall) + return args } func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) { @@ -6380,10 +7490,7 @@ func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsRet func (fake *FakeCloudControllerClient) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, ccv3.Warnings, error) { fake.getAppFeatureMutex.Lock() ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)] - fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, FakeCloudControllerClientGetAppFeatureArgs{arg1, arg2}) stub := fake.GetAppFeatureStub fakeReturns := fake.getAppFeatureReturns fake.recordInvocation("GetAppFeature", []interface{}{arg1, arg2}) @@ -6409,11 +7516,19 @@ func (fake *FakeCloudControllerClient) GetAppFeatureCalls(stub func(string, stri fake.GetAppFeatureStub = stub } -func (fake *FakeCloudControllerClient) GetAppFeatureArgsForCall(i int) (string, string) { +func (fake *FakeCloudControllerClient) GetAppFeatureArgsForCall(i int) (string, string) { + fake.getAppFeatureMutex.RLock() + defer fake.getAppFeatureMutex.RUnlock() + argsForCall := fake.getAppFeatureArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetAppFeatureArgs() []FakeCloudControllerClientGetAppFeatureArgs { fake.getAppFeatureMutex.RLock() defer fake.getAppFeatureMutex.RUnlock() - argsForCall := fake.getAppFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + args := make([]FakeCloudControllerClientGetAppFeatureArgs, len(fake.getAppFeatureArgsForCall)) + copy(args, fake.getAppFeatureArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetAppFeatureReturns(result1 resources.ApplicationFeature, result2 ccv3.Warnings, result3 error) { @@ -6448,10 +7563,7 @@ func (fake *FakeCloudControllerClient) GetAppFeatureReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpace(arg1 string, arg2 string) (resources.Application, ccv3.Warnings, error) { fake.getApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getApplicationByNameAndSpaceReturnsOnCall[len(fake.getApplicationByNameAndSpaceArgsForCall)] - fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, FakeCloudControllerClientGetApplicationByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetApplicationByNameAndSpaceStub fakeReturns := fake.getApplicationByNameAndSpaceReturns fake.recordInvocation("GetApplicationByNameAndSpace", []interface{}{arg1, arg2}) @@ -6481,7 +7593,15 @@ func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceArgsForCall(i fake.getApplicationByNameAndSpaceMutex.RLock() defer fake.getApplicationByNameAndSpaceMutex.RUnlock() argsForCall := fake.getApplicationByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceArgs() []FakeCloudControllerClientGetApplicationByNameAndSpaceArgs { + fake.getApplicationByNameAndSpaceMutex.RLock() + defer fake.getApplicationByNameAndSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationByNameAndSpaceArgs, len(fake.getApplicationByNameAndSpaceArgsForCall)) + copy(args, fake.getApplicationByNameAndSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -6516,9 +7636,7 @@ func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceReturnsOnCall func (fake *FakeCloudControllerClient) GetApplicationDropletCurrent(arg1 string) (resources.Droplet, ccv3.Warnings, error) { fake.getApplicationDropletCurrentMutex.Lock() ret, specificReturn := fake.getApplicationDropletCurrentReturnsOnCall[len(fake.getApplicationDropletCurrentArgsForCall)] - fake.getApplicationDropletCurrentArgsForCall = append(fake.getApplicationDropletCurrentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationDropletCurrentArgsForCall = append(fake.getApplicationDropletCurrentArgsForCall, FakeCloudControllerClientGetApplicationDropletCurrentArgs{arg1}) stub := fake.GetApplicationDropletCurrentStub fakeReturns := fake.getApplicationDropletCurrentReturns fake.recordInvocation("GetApplicationDropletCurrent", []interface{}{arg1}) @@ -6548,7 +7666,15 @@ func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentArgsForCall(i fake.getApplicationDropletCurrentMutex.RLock() defer fake.getApplicationDropletCurrentMutex.RUnlock() argsForCall := fake.getApplicationDropletCurrentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentArgs() []FakeCloudControllerClientGetApplicationDropletCurrentArgs { + fake.getApplicationDropletCurrentMutex.RLock() + defer fake.getApplicationDropletCurrentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationDropletCurrentArgs, len(fake.getApplicationDropletCurrentArgsForCall)) + copy(args, fake.getApplicationDropletCurrentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) { @@ -6583,9 +7709,7 @@ func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturnsOnCall func (fake *FakeCloudControllerClient) GetApplicationEnvironment(arg1 string) (ccv3.Environment, ccv3.Warnings, error) { fake.getApplicationEnvironmentMutex.Lock() ret, specificReturn := fake.getApplicationEnvironmentReturnsOnCall[len(fake.getApplicationEnvironmentArgsForCall)] - fake.getApplicationEnvironmentArgsForCall = append(fake.getApplicationEnvironmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationEnvironmentArgsForCall = append(fake.getApplicationEnvironmentArgsForCall, FakeCloudControllerClientGetApplicationEnvironmentArgs{arg1}) stub := fake.GetApplicationEnvironmentStub fakeReturns := fake.getApplicationEnvironmentReturns fake.recordInvocation("GetApplicationEnvironment", []interface{}{arg1}) @@ -6615,7 +7739,15 @@ func (fake *FakeCloudControllerClient) GetApplicationEnvironmentArgsForCall(i in fake.getApplicationEnvironmentMutex.RLock() defer fake.getApplicationEnvironmentMutex.RUnlock() argsForCall := fake.getApplicationEnvironmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationEnvironmentArgs() []FakeCloudControllerClientGetApplicationEnvironmentArgs { + fake.getApplicationEnvironmentMutex.RLock() + defer fake.getApplicationEnvironmentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationEnvironmentArgs, len(fake.getApplicationEnvironmentArgsForCall)) + copy(args, fake.getApplicationEnvironmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturns(result1 ccv3.Environment, result2 ccv3.Warnings, result3 error) { @@ -6650,9 +7782,7 @@ func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturnsOnCall(i func (fake *FakeCloudControllerClient) GetApplicationManifest(arg1 string) ([]byte, ccv3.Warnings, error) { fake.getApplicationManifestMutex.Lock() ret, specificReturn := fake.getApplicationManifestReturnsOnCall[len(fake.getApplicationManifestArgsForCall)] - fake.getApplicationManifestArgsForCall = append(fake.getApplicationManifestArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationManifestArgsForCall = append(fake.getApplicationManifestArgsForCall, FakeCloudControllerClientGetApplicationManifestArgs{arg1}) stub := fake.GetApplicationManifestStub fakeReturns := fake.getApplicationManifestReturns fake.recordInvocation("GetApplicationManifest", []interface{}{arg1}) @@ -6682,7 +7812,15 @@ func (fake *FakeCloudControllerClient) GetApplicationManifestArgsForCall(i int) fake.getApplicationManifestMutex.RLock() defer fake.getApplicationManifestMutex.RUnlock() argsForCall := fake.getApplicationManifestArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationManifestArgs() []FakeCloudControllerClientGetApplicationManifestArgs { + fake.getApplicationManifestMutex.RLock() + defer fake.getApplicationManifestMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationManifestArgs, len(fake.getApplicationManifestArgsForCall)) + copy(args, fake.getApplicationManifestArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationManifestReturns(result1 []byte, result2 ccv3.Warnings, result3 error) { @@ -6717,10 +7855,7 @@ func (fake *FakeCloudControllerClient) GetApplicationManifestReturnsOnCall(i int func (fake *FakeCloudControllerClient) GetApplicationProcessByType(arg1 string, arg2 string) (resources.Process, ccv3.Warnings, error) { fake.getApplicationProcessByTypeMutex.Lock() ret, specificReturn := fake.getApplicationProcessByTypeReturnsOnCall[len(fake.getApplicationProcessByTypeArgsForCall)] - fake.getApplicationProcessByTypeArgsForCall = append(fake.getApplicationProcessByTypeArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationProcessByTypeArgsForCall = append(fake.getApplicationProcessByTypeArgsForCall, FakeCloudControllerClientGetApplicationProcessByTypeArgs{arg1, arg2}) stub := fake.GetApplicationProcessByTypeStub fakeReturns := fake.getApplicationProcessByTypeReturns fake.recordInvocation("GetApplicationProcessByType", []interface{}{arg1, arg2}) @@ -6750,7 +7885,15 @@ func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeArgsForCall(i fake.getApplicationProcessByTypeMutex.RLock() defer fake.getApplicationProcessByTypeMutex.RUnlock() argsForCall := fake.getApplicationProcessByTypeArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeArgs() []FakeCloudControllerClientGetApplicationProcessByTypeArgs { + fake.getApplicationProcessByTypeMutex.RLock() + defer fake.getApplicationProcessByTypeMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationProcessByTypeArgs, len(fake.getApplicationProcessByTypeArgsForCall)) + copy(args, fake.getApplicationProcessByTypeArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) { @@ -6785,9 +7928,7 @@ func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturnsOnCall( func (fake *FakeCloudControllerClient) GetApplicationProcesses(arg1 string) ([]resources.Process, ccv3.Warnings, error) { fake.getApplicationProcessesMutex.Lock() ret, specificReturn := fake.getApplicationProcessesReturnsOnCall[len(fake.getApplicationProcessesArgsForCall)] - fake.getApplicationProcessesArgsForCall = append(fake.getApplicationProcessesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationProcessesArgsForCall = append(fake.getApplicationProcessesArgsForCall, FakeCloudControllerClientGetApplicationProcessesArgs{arg1}) stub := fake.GetApplicationProcessesStub fakeReturns := fake.getApplicationProcessesReturns fake.recordInvocation("GetApplicationProcesses", []interface{}{arg1}) @@ -6817,7 +7958,15 @@ func (fake *FakeCloudControllerClient) GetApplicationProcessesArgsForCall(i int) fake.getApplicationProcessesMutex.RLock() defer fake.getApplicationProcessesMutex.RUnlock() argsForCall := fake.getApplicationProcessesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationProcessesArgs() []FakeCloudControllerClientGetApplicationProcessesArgs { + fake.getApplicationProcessesMutex.RLock() + defer fake.getApplicationProcessesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationProcessesArgs, len(fake.getApplicationProcessesArgsForCall)) + copy(args, fake.getApplicationProcessesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) { @@ -6850,15 +7999,17 @@ func (fake *FakeCloudControllerClient) GetApplicationProcessesReturnsOnCall(i in } func (fake *FakeCloudControllerClient) GetApplicationRevisions(arg1 string, arg2 ...ccv3.Query) ([]resources.Revision, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getApplicationRevisionsMutex.Lock() ret, specificReturn := fake.getApplicationRevisionsReturnsOnCall[len(fake.getApplicationRevisionsArgsForCall)] - fake.getApplicationRevisionsArgsForCall = append(fake.getApplicationRevisionsArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getApplicationRevisionsArgsForCall = append(fake.getApplicationRevisionsArgsForCall, FakeCloudControllerClientGetApplicationRevisionsArgs{arg1, arg2Copy}) stub := fake.GetApplicationRevisionsStub fakeReturns := fake.getApplicationRevisionsReturns - fake.recordInvocation("GetApplicationRevisions", []interface{}{arg1, arg2}) + fake.recordInvocation("GetApplicationRevisions", []interface{}{arg1, arg2Copy}) fake.getApplicationRevisionsMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -6885,7 +8036,15 @@ func (fake *FakeCloudControllerClient) GetApplicationRevisionsArgsForCall(i int) fake.getApplicationRevisionsMutex.RLock() defer fake.getApplicationRevisionsMutex.RUnlock() argsForCall := fake.getApplicationRevisionsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetApplicationRevisionsArgs() []FakeCloudControllerClientGetApplicationRevisionsArgs { + fake.getApplicationRevisionsMutex.RLock() + defer fake.getApplicationRevisionsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationRevisionsArgs, len(fake.getApplicationRevisionsArgsForCall)) + copy(args, fake.getApplicationRevisionsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationRevisionsReturns(result1 []resources.Revision, result2 ccv3.Warnings, result3 error) { @@ -6920,9 +8079,7 @@ func (fake *FakeCloudControllerClient) GetApplicationRevisionsReturnsOnCall(i in func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployed(arg1 string) ([]resources.Revision, ccv3.Warnings, error) { fake.getApplicationRevisionsDeployedMutex.Lock() ret, specificReturn := fake.getApplicationRevisionsDeployedReturnsOnCall[len(fake.getApplicationRevisionsDeployedArgsForCall)] - fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, FakeCloudControllerClientGetApplicationRevisionsDeployedArgs{arg1}) stub := fake.GetApplicationRevisionsDeployedStub fakeReturns := fake.getApplicationRevisionsDeployedReturns fake.recordInvocation("GetApplicationRevisionsDeployed", []interface{}{arg1}) @@ -6952,7 +8109,15 @@ func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedArgsForCal fake.getApplicationRevisionsDeployedMutex.RLock() defer fake.getApplicationRevisionsDeployedMutex.RUnlock() argsForCall := fake.getApplicationRevisionsDeployedArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedArgs() []FakeCloudControllerClientGetApplicationRevisionsDeployedArgs { + fake.getApplicationRevisionsDeployedMutex.RLock() + defer fake.getApplicationRevisionsDeployedMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationRevisionsDeployedArgs, len(fake.getApplicationRevisionsDeployedArgsForCall)) + copy(args, fake.getApplicationRevisionsDeployedArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedReturns(result1 []resources.Revision, result2 ccv3.Warnings, result3 error) { @@ -6987,9 +8152,7 @@ func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedReturnsOnC func (fake *FakeCloudControllerClient) GetApplicationRoutes(arg1 string) ([]resources.Route, ccv3.Warnings, error) { fake.getApplicationRoutesMutex.Lock() ret, specificReturn := fake.getApplicationRoutesReturnsOnCall[len(fake.getApplicationRoutesArgsForCall)] - fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, FakeCloudControllerClientGetApplicationRoutesArgs{arg1}) stub := fake.GetApplicationRoutesStub fakeReturns := fake.getApplicationRoutesReturns fake.recordInvocation("GetApplicationRoutes", []interface{}{arg1}) @@ -7019,7 +8182,15 @@ func (fake *FakeCloudControllerClient) GetApplicationRoutesArgsForCall(i int) st fake.getApplicationRoutesMutex.RLock() defer fake.getApplicationRoutesMutex.RUnlock() argsForCall := fake.getApplicationRoutesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationRoutesArgs() []FakeCloudControllerClientGetApplicationRoutesArgs { + fake.getApplicationRoutesMutex.RLock() + defer fake.getApplicationRoutesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationRoutesArgs, len(fake.getApplicationRoutesArgsForCall)) + copy(args, fake.getApplicationRoutesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationRoutesReturns(result1 []resources.Route, result2 ccv3.Warnings, result3 error) { @@ -7052,15 +8223,17 @@ func (fake *FakeCloudControllerClient) GetApplicationRoutesReturnsOnCall(i int, } func (fake *FakeCloudControllerClient) GetApplicationTasks(arg1 string, arg2 ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getApplicationTasksMutex.Lock() ret, specificReturn := fake.getApplicationTasksReturnsOnCall[len(fake.getApplicationTasksArgsForCall)] - fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, FakeCloudControllerClientGetApplicationTasksArgs{arg1, arg2Copy}) stub := fake.GetApplicationTasksStub fakeReturns := fake.getApplicationTasksReturns - fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2}) + fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2Copy}) fake.getApplicationTasksMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -7087,7 +8260,15 @@ func (fake *FakeCloudControllerClient) GetApplicationTasksArgsForCall(i int) (st fake.getApplicationTasksMutex.RLock() defer fake.getApplicationTasksMutex.RUnlock() argsForCall := fake.getApplicationTasksArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetApplicationTasksArgs() []FakeCloudControllerClientGetApplicationTasksArgs { + fake.getApplicationTasksMutex.RLock() + defer fake.getApplicationTasksMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationTasksArgs, len(fake.getApplicationTasksArgsForCall)) + copy(args, fake.getApplicationTasksArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationTasksReturns(result1 []resources.Task, result2 ccv3.Warnings, result3 error) { @@ -7120,14 +8301,17 @@ func (fake *FakeCloudControllerClient) GetApplicationTasksReturnsOnCall(i int, r } func (fake *FakeCloudControllerClient) GetApplications(arg1 ...ccv3.Query) ([]resources.Application, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getApplicationsMutex.Lock() ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)] - fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, FakeCloudControllerClientGetApplicationsArgs{arg1Copy}) stub := fake.GetApplicationsStub fakeReturns := fake.getApplicationsReturns - fake.recordInvocation("GetApplications", []interface{}{arg1}) + fake.recordInvocation("GetApplications", []interface{}{arg1Copy}) fake.getApplicationsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7154,7 +8338,15 @@ func (fake *FakeCloudControllerClient) GetApplicationsArgsForCall(i int) []ccv3. fake.getApplicationsMutex.RLock() defer fake.getApplicationsMutex.RUnlock() argsForCall := fake.getApplicationsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetApplicationsArgs() []FakeCloudControllerClientGetApplicationsArgs { + fake.getApplicationsMutex.RLock() + defer fake.getApplicationsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetApplicationsArgs, len(fake.getApplicationsArgsForCall)) + copy(args, fake.getApplicationsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetApplicationsReturns(result1 []resources.Application, result2 ccv3.Warnings, result3 error) { @@ -7189,9 +8381,7 @@ func (fake *FakeCloudControllerClient) GetApplicationsReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) GetBuild(arg1 string) (resources.Build, ccv3.Warnings, error) { fake.getBuildMutex.Lock() ret, specificReturn := fake.getBuildReturnsOnCall[len(fake.getBuildArgsForCall)] - fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, struct { - arg1 string - }{arg1}) + fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, FakeCloudControllerClientGetBuildArgs{arg1}) stub := fake.GetBuildStub fakeReturns := fake.getBuildReturns fake.recordInvocation("GetBuild", []interface{}{arg1}) @@ -7221,7 +8411,15 @@ func (fake *FakeCloudControllerClient) GetBuildArgsForCall(i int) string { fake.getBuildMutex.RLock() defer fake.getBuildMutex.RUnlock() argsForCall := fake.getBuildArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetBuildArgs() []FakeCloudControllerClientGetBuildArgs { + fake.getBuildMutex.RLock() + defer fake.getBuildMutex.RUnlock() + args := make([]FakeCloudControllerClientGetBuildArgs, len(fake.getBuildArgsForCall)) + copy(args, fake.getBuildArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) { @@ -7254,14 +8452,17 @@ func (fake *FakeCloudControllerClient) GetBuildReturnsOnCall(i int, result1 reso } func (fake *FakeCloudControllerClient) GetBuildpacks(arg1 ...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getBuildpacksMutex.Lock() ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)] - fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, FakeCloudControllerClientGetBuildpacksArgs{arg1Copy}) stub := fake.GetBuildpacksStub fakeReturns := fake.getBuildpacksReturns - fake.recordInvocation("GetBuildpacks", []interface{}{arg1}) + fake.recordInvocation("GetBuildpacks", []interface{}{arg1Copy}) fake.getBuildpacksMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7288,7 +8489,15 @@ func (fake *FakeCloudControllerClient) GetBuildpacksArgsForCall(i int) []ccv3.Qu fake.getBuildpacksMutex.RLock() defer fake.getBuildpacksMutex.RUnlock() argsForCall := fake.getBuildpacksArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetBuildpacksArgs() []FakeCloudControllerClientGetBuildpacksArgs { + fake.getBuildpacksMutex.RLock() + defer fake.getBuildpacksMutex.RUnlock() + args := make([]FakeCloudControllerClientGetBuildpacksArgs, len(fake.getBuildpacksArgsForCall)) + copy(args, fake.getBuildpacksArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetBuildpacksReturns(result1 []resources.Buildpack, result2 ccv3.Warnings, result3 error) { @@ -7323,9 +8532,7 @@ func (fake *FakeCloudControllerClient) GetBuildpacksReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) GetDefaultDomain(arg1 string) (resources.Domain, ccv3.Warnings, error) { fake.getDefaultDomainMutex.Lock() ret, specificReturn := fake.getDefaultDomainReturnsOnCall[len(fake.getDefaultDomainArgsForCall)] - fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, FakeCloudControllerClientGetDefaultDomainArgs{arg1}) stub := fake.GetDefaultDomainStub fakeReturns := fake.getDefaultDomainReturns fake.recordInvocation("GetDefaultDomain", []interface{}{arg1}) @@ -7355,7 +8562,15 @@ func (fake *FakeCloudControllerClient) GetDefaultDomainArgsForCall(i int) string fake.getDefaultDomainMutex.RLock() defer fake.getDefaultDomainMutex.RUnlock() argsForCall := fake.getDefaultDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDefaultDomainArgs() []FakeCloudControllerClientGetDefaultDomainArgs { + fake.getDefaultDomainMutex.RLock() + defer fake.getDefaultDomainMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDefaultDomainArgs, len(fake.getDefaultDomainArgsForCall)) + copy(args, fake.getDefaultDomainArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDefaultDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) { @@ -7390,9 +8605,7 @@ func (fake *FakeCloudControllerClient) GetDefaultDomainReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) GetDeployment(arg1 string) (resources.Deployment, ccv3.Warnings, error) { fake.getDeploymentMutex.Lock() ret, specificReturn := fake.getDeploymentReturnsOnCall[len(fake.getDeploymentArgsForCall)] - fake.getDeploymentArgsForCall = append(fake.getDeploymentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDeploymentArgsForCall = append(fake.getDeploymentArgsForCall, FakeCloudControllerClientGetDeploymentArgs{arg1}) stub := fake.GetDeploymentStub fakeReturns := fake.getDeploymentReturns fake.recordInvocation("GetDeployment", []interface{}{arg1}) @@ -7422,7 +8635,15 @@ func (fake *FakeCloudControllerClient) GetDeploymentArgsForCall(i int) string { fake.getDeploymentMutex.RLock() defer fake.getDeploymentMutex.RUnlock() argsForCall := fake.getDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDeploymentArgs() []FakeCloudControllerClientGetDeploymentArgs { + fake.getDeploymentMutex.RLock() + defer fake.getDeploymentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDeploymentArgs, len(fake.getDeploymentArgsForCall)) + copy(args, fake.getDeploymentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDeploymentReturns(result1 resources.Deployment, result2 ccv3.Warnings, result3 error) { @@ -7455,14 +8676,17 @@ func (fake *FakeCloudControllerClient) GetDeploymentReturnsOnCall(i int, result1 } func (fake *FakeCloudControllerClient) GetDeployments(arg1 ...ccv3.Query) ([]resources.Deployment, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getDeploymentsMutex.Lock() ret, specificReturn := fake.getDeploymentsReturnsOnCall[len(fake.getDeploymentsArgsForCall)] - fake.getDeploymentsArgsForCall = append(fake.getDeploymentsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getDeploymentsArgsForCall = append(fake.getDeploymentsArgsForCall, FakeCloudControllerClientGetDeploymentsArgs{arg1Copy}) stub := fake.GetDeploymentsStub fakeReturns := fake.getDeploymentsReturns - fake.recordInvocation("GetDeployments", []interface{}{arg1}) + fake.recordInvocation("GetDeployments", []interface{}{arg1Copy}) fake.getDeploymentsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7489,7 +8713,15 @@ func (fake *FakeCloudControllerClient) GetDeploymentsArgsForCall(i int) []ccv3.Q fake.getDeploymentsMutex.RLock() defer fake.getDeploymentsMutex.RUnlock() argsForCall := fake.getDeploymentsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDeploymentsArgs() []FakeCloudControllerClientGetDeploymentsArgs { + fake.getDeploymentsMutex.RLock() + defer fake.getDeploymentsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDeploymentsArgs, len(fake.getDeploymentsArgsForCall)) + copy(args, fake.getDeploymentsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDeploymentsReturns(result1 []resources.Deployment, result2 ccv3.Warnings, result3 error) { @@ -7524,9 +8756,7 @@ func (fake *FakeCloudControllerClient) GetDeploymentsReturnsOnCall(i int, result func (fake *FakeCloudControllerClient) GetDomain(arg1 string) (resources.Domain, ccv3.Warnings, error) { fake.getDomainMutex.Lock() ret, specificReturn := fake.getDomainReturnsOnCall[len(fake.getDomainArgsForCall)] - fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, FakeCloudControllerClientGetDomainArgs{arg1}) stub := fake.GetDomainStub fakeReturns := fake.getDomainReturns fake.recordInvocation("GetDomain", []interface{}{arg1}) @@ -7556,7 +8786,15 @@ func (fake *FakeCloudControllerClient) GetDomainArgsForCall(i int) string { fake.getDomainMutex.RLock() defer fake.getDomainMutex.RUnlock() argsForCall := fake.getDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDomainArgs() []FakeCloudControllerClientGetDomainArgs { + fake.getDomainMutex.RLock() + defer fake.getDomainMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDomainArgs, len(fake.getDomainArgsForCall)) + copy(args, fake.getDomainArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) { @@ -7589,14 +8827,17 @@ func (fake *FakeCloudControllerClient) GetDomainReturnsOnCall(i int, result1 res } func (fake *FakeCloudControllerClient) GetDomains(arg1 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getDomainsMutex.Lock() ret, specificReturn := fake.getDomainsReturnsOnCall[len(fake.getDomainsArgsForCall)] - fake.getDomainsArgsForCall = append(fake.getDomainsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getDomainsArgsForCall = append(fake.getDomainsArgsForCall, FakeCloudControllerClientGetDomainsArgs{arg1Copy}) stub := fake.GetDomainsStub fakeReturns := fake.getDomainsReturns - fake.recordInvocation("GetDomains", []interface{}{arg1}) + fake.recordInvocation("GetDomains", []interface{}{arg1Copy}) fake.getDomainsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7623,7 +8864,15 @@ func (fake *FakeCloudControllerClient) GetDomainsArgsForCall(i int) []ccv3.Query fake.getDomainsMutex.RLock() defer fake.getDomainsMutex.RUnlock() argsForCall := fake.getDomainsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDomainsArgs() []FakeCloudControllerClientGetDomainsArgs { + fake.getDomainsMutex.RLock() + defer fake.getDomainsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDomainsArgs, len(fake.getDomainsArgsForCall)) + copy(args, fake.getDomainsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) { @@ -7658,9 +8907,7 @@ func (fake *FakeCloudControllerClient) GetDomainsReturnsOnCall(i int, result1 [] func (fake *FakeCloudControllerClient) GetDroplet(arg1 string) (resources.Droplet, ccv3.Warnings, error) { fake.getDropletMutex.Lock() ret, specificReturn := fake.getDropletReturnsOnCall[len(fake.getDropletArgsForCall)] - fake.getDropletArgsForCall = append(fake.getDropletArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDropletArgsForCall = append(fake.getDropletArgsForCall, FakeCloudControllerClientGetDropletArgs{arg1}) stub := fake.GetDropletStub fakeReturns := fake.getDropletReturns fake.recordInvocation("GetDroplet", []interface{}{arg1}) @@ -7690,7 +8937,15 @@ func (fake *FakeCloudControllerClient) GetDropletArgsForCall(i int) string { fake.getDropletMutex.RLock() defer fake.getDropletMutex.RUnlock() argsForCall := fake.getDropletArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDropletArgs() []FakeCloudControllerClientGetDropletArgs { + fake.getDropletMutex.RLock() + defer fake.getDropletMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDropletArgs, len(fake.getDropletArgsForCall)) + copy(args, fake.getDropletArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDropletReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) { @@ -7723,14 +8978,17 @@ func (fake *FakeCloudControllerClient) GetDropletReturnsOnCall(i int, result1 re } func (fake *FakeCloudControllerClient) GetDroplets(arg1 ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getDropletsMutex.Lock() ret, specificReturn := fake.getDropletsReturnsOnCall[len(fake.getDropletsArgsForCall)] - fake.getDropletsArgsForCall = append(fake.getDropletsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getDropletsArgsForCall = append(fake.getDropletsArgsForCall, FakeCloudControllerClientGetDropletsArgs{arg1Copy}) stub := fake.GetDropletsStub fakeReturns := fake.getDropletsReturns - fake.recordInvocation("GetDroplets", []interface{}{arg1}) + fake.recordInvocation("GetDroplets", []interface{}{arg1Copy}) fake.getDropletsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7757,7 +9015,15 @@ func (fake *FakeCloudControllerClient) GetDropletsArgsForCall(i int) []ccv3.Quer fake.getDropletsMutex.RLock() defer fake.getDropletsMutex.RUnlock() argsForCall := fake.getDropletsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetDropletsArgs() []FakeCloudControllerClientGetDropletsArgs { + fake.getDropletsMutex.RLock() + defer fake.getDropletsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetDropletsArgs, len(fake.getDropletsArgsForCall)) + copy(args, fake.getDropletsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetDropletsReturns(result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) { @@ -7792,9 +9058,7 @@ func (fake *FakeCloudControllerClient) GetDropletsReturnsOnCall(i int, result1 [ func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroup(arg1 constant.EnvironmentVariableGroupName) (resources.EnvironmentVariables, ccv3.Warnings, error) { fake.getEnvironmentVariableGroupMutex.Lock() ret, specificReturn := fake.getEnvironmentVariableGroupReturnsOnCall[len(fake.getEnvironmentVariableGroupArgsForCall)] - fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, struct { - arg1 constant.EnvironmentVariableGroupName - }{arg1}) + fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, FakeCloudControllerClientGetEnvironmentVariableGroupArgs{arg1}) stub := fake.GetEnvironmentVariableGroupStub fakeReturns := fake.getEnvironmentVariableGroupReturns fake.recordInvocation("GetEnvironmentVariableGroup", []interface{}{arg1}) @@ -7824,7 +9088,15 @@ func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupArgsForCall(i fake.getEnvironmentVariableGroupMutex.RLock() defer fake.getEnvironmentVariableGroupMutex.RUnlock() argsForCall := fake.getEnvironmentVariableGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupArgs() []FakeCloudControllerClientGetEnvironmentVariableGroupArgs { + fake.getEnvironmentVariableGroupMutex.RLock() + defer fake.getEnvironmentVariableGroupMutex.RUnlock() + args := make([]FakeCloudControllerClientGetEnvironmentVariableGroupArgs, len(fake.getEnvironmentVariableGroupArgsForCall)) + copy(args, fake.getEnvironmentVariableGroupArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) { @@ -7859,9 +9131,7 @@ func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupReturnsOnCall( func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURL(arg1 string) (resources.EnvironmentVariables, ccv3.Warnings, error) { fake.getEnvironmentVariablesByURLMutex.Lock() ret, specificReturn := fake.getEnvironmentVariablesByURLReturnsOnCall[len(fake.getEnvironmentVariablesByURLArgsForCall)] - fake.getEnvironmentVariablesByURLArgsForCall = append(fake.getEnvironmentVariablesByURLArgsForCall, struct { - arg1 string - }{arg1}) + fake.getEnvironmentVariablesByURLArgsForCall = append(fake.getEnvironmentVariablesByURLArgsForCall, FakeCloudControllerClientGetEnvironmentVariablesByURLArgs{arg1}) stub := fake.GetEnvironmentVariablesByURLStub fakeReturns := fake.getEnvironmentVariablesByURLReturns fake.recordInvocation("GetEnvironmentVariablesByURL", []interface{}{arg1}) @@ -7891,7 +9161,15 @@ func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLArgsForCall(i fake.getEnvironmentVariablesByURLMutex.RLock() defer fake.getEnvironmentVariablesByURLMutex.RUnlock() argsForCall := fake.getEnvironmentVariablesByURLArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLArgs() []FakeCloudControllerClientGetEnvironmentVariablesByURLArgs { + fake.getEnvironmentVariablesByURLMutex.RLock() + defer fake.getEnvironmentVariablesByURLMutex.RUnlock() + args := make([]FakeCloudControllerClientGetEnvironmentVariablesByURLArgs, len(fake.getEnvironmentVariablesByURLArgsForCall)) + copy(args, fake.getEnvironmentVariablesByURLArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) { @@ -7924,14 +9202,17 @@ func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLReturnsOnCall } func (fake *FakeCloudControllerClient) GetEvents(arg1 ...ccv3.Query) ([]ccv3.Event, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getEventsMutex.Lock() ret, specificReturn := fake.getEventsReturnsOnCall[len(fake.getEventsArgsForCall)] - fake.getEventsArgsForCall = append(fake.getEventsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getEventsArgsForCall = append(fake.getEventsArgsForCall, FakeCloudControllerClientGetEventsArgs{arg1Copy}) stub := fake.GetEventsStub fakeReturns := fake.getEventsReturns - fake.recordInvocation("GetEvents", []interface{}{arg1}) + fake.recordInvocation("GetEvents", []interface{}{arg1Copy}) fake.getEventsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -7958,7 +9239,15 @@ func (fake *FakeCloudControllerClient) GetEventsArgsForCall(i int) []ccv3.Query fake.getEventsMutex.RLock() defer fake.getEventsMutex.RUnlock() argsForCall := fake.getEventsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetEventsArgs() []FakeCloudControllerClientGetEventsArgs { + fake.getEventsMutex.RLock() + defer fake.getEventsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetEventsArgs, len(fake.getEventsArgsForCall)) + copy(args, fake.getEventsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetEventsReturns(result1 []ccv3.Event, result2 ccv3.Warnings, result3 error) { @@ -7993,9 +9282,7 @@ func (fake *FakeCloudControllerClient) GetEventsReturnsOnCall(i int, result1 []c func (fake *FakeCloudControllerClient) GetFeatureFlag(arg1 string) (resources.FeatureFlag, ccv3.Warnings, error) { fake.getFeatureFlagMutex.Lock() ret, specificReturn := fake.getFeatureFlagReturnsOnCall[len(fake.getFeatureFlagArgsForCall)] - fake.getFeatureFlagArgsForCall = append(fake.getFeatureFlagArgsForCall, struct { - arg1 string - }{arg1}) + fake.getFeatureFlagArgsForCall = append(fake.getFeatureFlagArgsForCall, FakeCloudControllerClientGetFeatureFlagArgs{arg1}) stub := fake.GetFeatureFlagStub fakeReturns := fake.getFeatureFlagReturns fake.recordInvocation("GetFeatureFlag", []interface{}{arg1}) @@ -8025,7 +9312,15 @@ func (fake *FakeCloudControllerClient) GetFeatureFlagArgsForCall(i int) string { fake.getFeatureFlagMutex.RLock() defer fake.getFeatureFlagMutex.RUnlock() argsForCall := fake.getFeatureFlagArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetFeatureFlagArgs() []FakeCloudControllerClientGetFeatureFlagArgs { + fake.getFeatureFlagMutex.RLock() + defer fake.getFeatureFlagMutex.RUnlock() + args := make([]FakeCloudControllerClientGetFeatureFlagArgs, len(fake.getFeatureFlagArgsForCall)) + copy(args, fake.getFeatureFlagArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) { @@ -8060,8 +9355,7 @@ func (fake *FakeCloudControllerClient) GetFeatureFlagReturnsOnCall(i int, result func (fake *FakeCloudControllerClient) GetFeatureFlags() ([]resources.FeatureFlag, ccv3.Warnings, error) { fake.getFeatureFlagsMutex.Lock() ret, specificReturn := fake.getFeatureFlagsReturnsOnCall[len(fake.getFeatureFlagsArgsForCall)] - fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct { - }{}) + fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct{}{}) stub := fake.GetFeatureFlagsStub fakeReturns := fake.getFeatureFlagsReturns fake.recordInvocation("GetFeatureFlags", []interface{}{}) @@ -8119,8 +9413,7 @@ func (fake *FakeCloudControllerClient) GetFeatureFlagsReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) GetInfo() (ccv3.Info, ccv3.Warnings, error) { fake.getInfoMutex.Lock() ret, specificReturn := fake.getInfoReturnsOnCall[len(fake.getInfoArgsForCall)] - fake.getInfoArgsForCall = append(fake.getInfoArgsForCall, struct { - }{}) + fake.getInfoArgsForCall = append(fake.getInfoArgsForCall, struct{}{}) stub := fake.GetInfoStub fakeReturns := fake.getInfoReturns fake.recordInvocation("GetInfo", []interface{}{}) @@ -8178,9 +9471,7 @@ func (fake *FakeCloudControllerClient) GetInfoReturnsOnCall(i int, result1 ccv3. func (fake *FakeCloudControllerClient) GetIsolationSegment(arg1 string) (resources.IsolationSegment, ccv3.Warnings, error) { fake.getIsolationSegmentMutex.Lock() ret, specificReturn := fake.getIsolationSegmentReturnsOnCall[len(fake.getIsolationSegmentArgsForCall)] - fake.getIsolationSegmentArgsForCall = append(fake.getIsolationSegmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getIsolationSegmentArgsForCall = append(fake.getIsolationSegmentArgsForCall, FakeCloudControllerClientGetIsolationSegmentArgs{arg1}) stub := fake.GetIsolationSegmentStub fakeReturns := fake.getIsolationSegmentReturns fake.recordInvocation("GetIsolationSegment", []interface{}{arg1}) @@ -8210,7 +9501,15 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentArgsForCall(i int) str fake.getIsolationSegmentMutex.RLock() defer fake.getIsolationSegmentMutex.RUnlock() argsForCall := fake.getIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetIsolationSegmentArgs() []FakeCloudControllerClientGetIsolationSegmentArgs { + fake.getIsolationSegmentMutex.RLock() + defer fake.getIsolationSegmentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetIsolationSegmentArgs, len(fake.getIsolationSegmentArgsForCall)) + copy(args, fake.getIsolationSegmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) { @@ -8245,9 +9544,7 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizations(arg1 string) ([]resources.Organization, ccv3.Warnings, error) { fake.getIsolationSegmentOrganizationsMutex.Lock() ret, specificReturn := fake.getIsolationSegmentOrganizationsReturnsOnCall[len(fake.getIsolationSegmentOrganizationsArgsForCall)] - fake.getIsolationSegmentOrganizationsArgsForCall = append(fake.getIsolationSegmentOrganizationsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getIsolationSegmentOrganizationsArgsForCall = append(fake.getIsolationSegmentOrganizationsArgsForCall, FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs{arg1}) stub := fake.GetIsolationSegmentOrganizationsStub fakeReturns := fake.getIsolationSegmentOrganizationsReturns fake.recordInvocation("GetIsolationSegmentOrganizations", []interface{}{arg1}) @@ -8277,7 +9574,15 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsArgsForCa fake.getIsolationSegmentOrganizationsMutex.RLock() defer fake.getIsolationSegmentOrganizationsMutex.RUnlock() argsForCall := fake.getIsolationSegmentOrganizationsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsArgs() []FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs { + fake.getIsolationSegmentOrganizationsMutex.RLock() + defer fake.getIsolationSegmentOrganizationsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetIsolationSegmentOrganizationsArgs, len(fake.getIsolationSegmentOrganizationsArgsForCall)) + copy(args, fake.getIsolationSegmentOrganizationsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturns(result1 []resources.Organization, result2 ccv3.Warnings, result3 error) { @@ -8310,14 +9615,17 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturnsOn } func (fake *FakeCloudControllerClient) GetIsolationSegments(arg1 ...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getIsolationSegmentsMutex.Lock() ret, specificReturn := fake.getIsolationSegmentsReturnsOnCall[len(fake.getIsolationSegmentsArgsForCall)] - fake.getIsolationSegmentsArgsForCall = append(fake.getIsolationSegmentsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getIsolationSegmentsArgsForCall = append(fake.getIsolationSegmentsArgsForCall, FakeCloudControllerClientGetIsolationSegmentsArgs{arg1Copy}) stub := fake.GetIsolationSegmentsStub fakeReturns := fake.getIsolationSegmentsReturns - fake.recordInvocation("GetIsolationSegments", []interface{}{arg1}) + fake.recordInvocation("GetIsolationSegments", []interface{}{arg1Copy}) fake.getIsolationSegmentsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -8344,7 +9652,15 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentsArgsForCall(i int) [] fake.getIsolationSegmentsMutex.RLock() defer fake.getIsolationSegmentsMutex.RUnlock() argsForCall := fake.getIsolationSegmentsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetIsolationSegmentsArgs() []FakeCloudControllerClientGetIsolationSegmentsArgs { + fake.getIsolationSegmentsMutex.RLock() + defer fake.getIsolationSegmentsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetIsolationSegmentsArgs, len(fake.getIsolationSegmentsArgsForCall)) + copy(args, fake.getIsolationSegmentsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturns(result1 []resources.IsolationSegment, result2 ccv3.Warnings, result3 error) { @@ -8379,10 +9695,7 @@ func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturnsOnCall(i int, func (fake *FakeCloudControllerClient) GetNewApplicationProcesses(arg1 string, arg2 string) ([]resources.Process, ccv3.Warnings, error) { fake.getNewApplicationProcessesMutex.Lock() ret, specificReturn := fake.getNewApplicationProcessesReturnsOnCall[len(fake.getNewApplicationProcessesArgsForCall)] - fake.getNewApplicationProcessesArgsForCall = append(fake.getNewApplicationProcessesArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getNewApplicationProcessesArgsForCall = append(fake.getNewApplicationProcessesArgsForCall, FakeCloudControllerClientGetNewApplicationProcessesArgs{arg1, arg2}) stub := fake.GetNewApplicationProcessesStub fakeReturns := fake.getNewApplicationProcessesReturns fake.recordInvocation("GetNewApplicationProcesses", []interface{}{arg1, arg2}) @@ -8412,7 +9725,15 @@ func (fake *FakeCloudControllerClient) GetNewApplicationProcessesArgsForCall(i i fake.getNewApplicationProcessesMutex.RLock() defer fake.getNewApplicationProcessesMutex.RUnlock() argsForCall := fake.getNewApplicationProcessesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetNewApplicationProcessesArgs() []FakeCloudControllerClientGetNewApplicationProcessesArgs { + fake.getNewApplicationProcessesMutex.RLock() + defer fake.getNewApplicationProcessesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetNewApplicationProcessesArgs, len(fake.getNewApplicationProcessesArgsForCall)) + copy(args, fake.getNewApplicationProcessesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetNewApplicationProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) { @@ -8447,9 +9768,7 @@ func (fake *FakeCloudControllerClient) GetNewApplicationProcessesReturnsOnCall(i func (fake *FakeCloudControllerClient) GetOrganization(arg1 string) (resources.Organization, ccv3.Warnings, error) { fake.getOrganizationMutex.Lock() ret, specificReturn := fake.getOrganizationReturnsOnCall[len(fake.getOrganizationArgsForCall)] - fake.getOrganizationArgsForCall = append(fake.getOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationArgsForCall = append(fake.getOrganizationArgsForCall, FakeCloudControllerClientGetOrganizationArgs{arg1}) stub := fake.GetOrganizationStub fakeReturns := fake.getOrganizationReturns fake.recordInvocation("GetOrganization", []interface{}{arg1}) @@ -8479,7 +9798,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationArgsForCall(i int) string fake.getOrganizationMutex.RLock() defer fake.getOrganizationMutex.RUnlock() argsForCall := fake.getOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetOrganizationArgs() []FakeCloudControllerClientGetOrganizationArgs { + fake.getOrganizationMutex.RLock() + defer fake.getOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationArgs, len(fake.getOrganizationArgsForCall)) + copy(args, fake.getOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) { @@ -8514,9 +9841,7 @@ func (fake *FakeCloudControllerClient) GetOrganizationReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) { fake.getOrganizationDefaultIsolationSegmentMutex.Lock() ret, specificReturn := fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)] - fake.getOrganizationDefaultIsolationSegmentArgsForCall = append(fake.getOrganizationDefaultIsolationSegmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationDefaultIsolationSegmentArgsForCall = append(fake.getOrganizationDefaultIsolationSegmentArgsForCall, FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs{arg1}) stub := fake.GetOrganizationDefaultIsolationSegmentStub fakeReturns := fake.getOrganizationDefaultIsolationSegmentReturns fake.recordInvocation("GetOrganizationDefaultIsolationSegment", []interface{}{arg1}) @@ -8546,7 +9871,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentArg fake.getOrganizationDefaultIsolationSegmentMutex.RLock() defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock() argsForCall := fake.getOrganizationDefaultIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentArgs() []FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs { + fake.getOrganizationDefaultIsolationSegmentMutex.RLock() + defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationDefaultIsolationSegmentArgs, len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)) + copy(args, fake.getOrganizationDefaultIsolationSegmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) { @@ -8579,15 +9912,17 @@ func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentRet } func (fake *FakeCloudControllerClient) GetOrganizationDomains(arg1 string, arg2 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getOrganizationDomainsMutex.Lock() ret, specificReturn := fake.getOrganizationDomainsReturnsOnCall[len(fake.getOrganizationDomainsArgsForCall)] - fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, FakeCloudControllerClientGetOrganizationDomainsArgs{arg1, arg2Copy}) stub := fake.GetOrganizationDomainsStub fakeReturns := fake.getOrganizationDomainsReturns - fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2}) + fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2Copy}) fake.getOrganizationDomainsMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -8614,7 +9949,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationDomainsArgsForCall(i int) fake.getOrganizationDomainsMutex.RLock() defer fake.getOrganizationDomainsMutex.RUnlock() argsForCall := fake.getOrganizationDomainsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetOrganizationDomainsArgs() []FakeCloudControllerClientGetOrganizationDomainsArgs { + fake.getOrganizationDomainsMutex.RLock() + defer fake.getOrganizationDomainsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationDomainsArgs, len(fake.getOrganizationDomainsArgsForCall)) + copy(args, fake.getOrganizationDomainsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) { @@ -8649,9 +9992,7 @@ func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturnsOnCall(i int func (fake *FakeCloudControllerClient) GetOrganizationQuota(arg1 string) (resources.OrganizationQuota, ccv3.Warnings, error) { fake.getOrganizationQuotaMutex.Lock() ret, specificReturn := fake.getOrganizationQuotaReturnsOnCall[len(fake.getOrganizationQuotaArgsForCall)] - fake.getOrganizationQuotaArgsForCall = append(fake.getOrganizationQuotaArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationQuotaArgsForCall = append(fake.getOrganizationQuotaArgsForCall, FakeCloudControllerClientGetOrganizationQuotaArgs{arg1}) stub := fake.GetOrganizationQuotaStub fakeReturns := fake.getOrganizationQuotaReturns fake.recordInvocation("GetOrganizationQuota", []interface{}{arg1}) @@ -8681,7 +10022,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationQuotaArgsForCall(i int) st fake.getOrganizationQuotaMutex.RLock() defer fake.getOrganizationQuotaMutex.RUnlock() argsForCall := fake.getOrganizationQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetOrganizationQuotaArgs() []FakeCloudControllerClientGetOrganizationQuotaArgs { + fake.getOrganizationQuotaMutex.RLock() + defer fake.getOrganizationQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationQuotaArgs, len(fake.getOrganizationQuotaArgsForCall)) + copy(args, fake.getOrganizationQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) { @@ -8714,14 +10063,17 @@ func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturnsOnCall(i int, } func (fake *FakeCloudControllerClient) GetOrganizationQuotas(arg1 ...ccv3.Query) ([]resources.OrganizationQuota, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getOrganizationQuotasMutex.Lock() ret, specificReturn := fake.getOrganizationQuotasReturnsOnCall[len(fake.getOrganizationQuotasArgsForCall)] - fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, FakeCloudControllerClientGetOrganizationQuotasArgs{arg1Copy}) stub := fake.GetOrganizationQuotasStub fakeReturns := fake.getOrganizationQuotasReturns - fake.recordInvocation("GetOrganizationQuotas", []interface{}{arg1}) + fake.recordInvocation("GetOrganizationQuotas", []interface{}{arg1Copy}) fake.getOrganizationQuotasMutex.Unlock() if stub != nil { return stub(arg1...) @@ -8748,7 +10100,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationQuotasArgsForCall(i int) [ fake.getOrganizationQuotasMutex.RLock() defer fake.getOrganizationQuotasMutex.RUnlock() argsForCall := fake.getOrganizationQuotasArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetOrganizationQuotasArgs() []FakeCloudControllerClientGetOrganizationQuotasArgs { + fake.getOrganizationQuotasMutex.RLock() + defer fake.getOrganizationQuotasMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationQuotasArgs, len(fake.getOrganizationQuotasArgsForCall)) + copy(args, fake.getOrganizationQuotasArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturns(result1 []resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) { @@ -8781,14 +10141,17 @@ func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturnsOnCall(i int, } func (fake *FakeCloudControllerClient) GetOrganizations(arg1 ...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getOrganizationsMutex.Lock() ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)] - fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, FakeCloudControllerClientGetOrganizationsArgs{arg1Copy}) stub := fake.GetOrganizationsStub fakeReturns := fake.getOrganizationsReturns - fake.recordInvocation("GetOrganizations", []interface{}{arg1}) + fake.recordInvocation("GetOrganizations", []interface{}{arg1Copy}) fake.getOrganizationsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -8815,7 +10178,15 @@ func (fake *FakeCloudControllerClient) GetOrganizationsArgsForCall(i int) []ccv3 fake.getOrganizationsMutex.RLock() defer fake.getOrganizationsMutex.RUnlock() argsForCall := fake.getOrganizationsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetOrganizationsArgs() []FakeCloudControllerClientGetOrganizationsArgs { + fake.getOrganizationsMutex.RLock() + defer fake.getOrganizationsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetOrganizationsArgs, len(fake.getOrganizationsArgsForCall)) + copy(args, fake.getOrganizationsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetOrganizationsReturns(result1 []resources.Organization, result2 ccv3.Warnings, result3 error) { @@ -8850,9 +10221,7 @@ func (fake *FakeCloudControllerClient) GetOrganizationsReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) GetPackage(arg1 string) (resources.Package, ccv3.Warnings, error) { fake.getPackageMutex.Lock() ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)] - fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct { - arg1 string - }{arg1}) + fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, FakeCloudControllerClientGetPackageArgs{arg1}) stub := fake.GetPackageStub fakeReturns := fake.getPackageReturns fake.recordInvocation("GetPackage", []interface{}{arg1}) @@ -8882,7 +10251,15 @@ func (fake *FakeCloudControllerClient) GetPackageArgsForCall(i int) string { fake.getPackageMutex.RLock() defer fake.getPackageMutex.RUnlock() argsForCall := fake.getPackageArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetPackageArgs() []FakeCloudControllerClientGetPackageArgs { + fake.getPackageMutex.RLock() + defer fake.getPackageMutex.RUnlock() + args := make([]FakeCloudControllerClientGetPackageArgs, len(fake.getPackageArgsForCall)) + copy(args, fake.getPackageArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) { @@ -8915,15 +10292,17 @@ func (fake *FakeCloudControllerClient) GetPackageReturnsOnCall(i int, result1 re } func (fake *FakeCloudControllerClient) GetPackageDroplets(arg1 string, arg2 ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getPackageDropletsMutex.Lock() ret, specificReturn := fake.getPackageDropletsReturnsOnCall[len(fake.getPackageDropletsArgsForCall)] - fake.getPackageDropletsArgsForCall = append(fake.getPackageDropletsArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getPackageDropletsArgsForCall = append(fake.getPackageDropletsArgsForCall, FakeCloudControllerClientGetPackageDropletsArgs{arg1, arg2Copy}) stub := fake.GetPackageDropletsStub fakeReturns := fake.getPackageDropletsReturns - fake.recordInvocation("GetPackageDroplets", []interface{}{arg1, arg2}) + fake.recordInvocation("GetPackageDroplets", []interface{}{arg1, arg2Copy}) fake.getPackageDropletsMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -8950,7 +10329,15 @@ func (fake *FakeCloudControllerClient) GetPackageDropletsArgsForCall(i int) (str fake.getPackageDropletsMutex.RLock() defer fake.getPackageDropletsMutex.RUnlock() argsForCall := fake.getPackageDropletsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetPackageDropletsArgs() []FakeCloudControllerClientGetPackageDropletsArgs { + fake.getPackageDropletsMutex.RLock() + defer fake.getPackageDropletsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetPackageDropletsArgs, len(fake.getPackageDropletsArgsForCall)) + copy(args, fake.getPackageDropletsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetPackageDropletsReturns(result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) { @@ -8983,14 +10370,17 @@ func (fake *FakeCloudControllerClient) GetPackageDropletsReturnsOnCall(i int, re } func (fake *FakeCloudControllerClient) GetPackages(arg1 ...ccv3.Query) ([]resources.Package, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getPackagesMutex.Lock() ret, specificReturn := fake.getPackagesReturnsOnCall[len(fake.getPackagesArgsForCall)] - fake.getPackagesArgsForCall = append(fake.getPackagesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getPackagesArgsForCall = append(fake.getPackagesArgsForCall, FakeCloudControllerClientGetPackagesArgs{arg1Copy}) stub := fake.GetPackagesStub fakeReturns := fake.getPackagesReturns - fake.recordInvocation("GetPackages", []interface{}{arg1}) + fake.recordInvocation("GetPackages", []interface{}{arg1Copy}) fake.getPackagesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9017,7 +10407,15 @@ func (fake *FakeCloudControllerClient) GetPackagesArgsForCall(i int) []ccv3.Quer fake.getPackagesMutex.RLock() defer fake.getPackagesMutex.RUnlock() argsForCall := fake.getPackagesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetPackagesArgs() []FakeCloudControllerClientGetPackagesArgs { + fake.getPackagesMutex.RLock() + defer fake.getPackagesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetPackagesArgs, len(fake.getPackagesArgsForCall)) + copy(args, fake.getPackagesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetPackagesReturns(result1 []resources.Package, result2 ccv3.Warnings, result3 error) { @@ -9052,9 +10450,7 @@ func (fake *FakeCloudControllerClient) GetPackagesReturnsOnCall(i int, result1 [ func (fake *FakeCloudControllerClient) GetProcess(arg1 string) (resources.Process, ccv3.Warnings, error) { fake.getProcessMutex.Lock() ret, specificReturn := fake.getProcessReturnsOnCall[len(fake.getProcessArgsForCall)] - fake.getProcessArgsForCall = append(fake.getProcessArgsForCall, struct { - arg1 string - }{arg1}) + fake.getProcessArgsForCall = append(fake.getProcessArgsForCall, FakeCloudControllerClientGetProcessArgs{arg1}) stub := fake.GetProcessStub fakeReturns := fake.getProcessReturns fake.recordInvocation("GetProcess", []interface{}{arg1}) @@ -9084,7 +10480,15 @@ func (fake *FakeCloudControllerClient) GetProcessArgsForCall(i int) string { fake.getProcessMutex.RLock() defer fake.getProcessMutex.RUnlock() argsForCall := fake.getProcessArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetProcessArgs() []FakeCloudControllerClientGetProcessArgs { + fake.getProcessMutex.RLock() + defer fake.getProcessMutex.RUnlock() + args := make([]FakeCloudControllerClientGetProcessArgs, len(fake.getProcessArgsForCall)) + copy(args, fake.getProcessArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetProcessReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) { @@ -9119,9 +10523,7 @@ func (fake *FakeCloudControllerClient) GetProcessReturnsOnCall(i int, result1 re func (fake *FakeCloudControllerClient) GetProcessInstances(arg1 string) ([]ccv3.ProcessInstance, ccv3.Warnings, error) { fake.getProcessInstancesMutex.Lock() ret, specificReturn := fake.getProcessInstancesReturnsOnCall[len(fake.getProcessInstancesArgsForCall)] - fake.getProcessInstancesArgsForCall = append(fake.getProcessInstancesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getProcessInstancesArgsForCall = append(fake.getProcessInstancesArgsForCall, FakeCloudControllerClientGetProcessInstancesArgs{arg1}) stub := fake.GetProcessInstancesStub fakeReturns := fake.getProcessInstancesReturns fake.recordInvocation("GetProcessInstances", []interface{}{arg1}) @@ -9151,7 +10553,15 @@ func (fake *FakeCloudControllerClient) GetProcessInstancesArgsForCall(i int) str fake.getProcessInstancesMutex.RLock() defer fake.getProcessInstancesMutex.RUnlock() argsForCall := fake.getProcessInstancesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetProcessInstancesArgs() []FakeCloudControllerClientGetProcessInstancesArgs { + fake.getProcessInstancesMutex.RLock() + defer fake.getProcessInstancesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetProcessInstancesArgs, len(fake.getProcessInstancesArgsForCall)) + copy(args, fake.getProcessInstancesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetProcessInstancesReturns(result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) { @@ -9186,9 +10596,7 @@ func (fake *FakeCloudControllerClient) GetProcessInstancesReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) GetProcessSidecars(arg1 string) ([]resources.Sidecar, ccv3.Warnings, error) { fake.getProcessSidecarsMutex.Lock() ret, specificReturn := fake.getProcessSidecarsReturnsOnCall[len(fake.getProcessSidecarsArgsForCall)] - fake.getProcessSidecarsArgsForCall = append(fake.getProcessSidecarsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getProcessSidecarsArgsForCall = append(fake.getProcessSidecarsArgsForCall, FakeCloudControllerClientGetProcessSidecarsArgs{arg1}) stub := fake.GetProcessSidecarsStub fakeReturns := fake.getProcessSidecarsReturns fake.recordInvocation("GetProcessSidecars", []interface{}{arg1}) @@ -9218,7 +10626,15 @@ func (fake *FakeCloudControllerClient) GetProcessSidecarsArgsForCall(i int) stri fake.getProcessSidecarsMutex.RLock() defer fake.getProcessSidecarsMutex.RUnlock() argsForCall := fake.getProcessSidecarsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetProcessSidecarsArgs() []FakeCloudControllerClientGetProcessSidecarsArgs { + fake.getProcessSidecarsMutex.RLock() + defer fake.getProcessSidecarsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetProcessSidecarsArgs, len(fake.getProcessSidecarsArgsForCall)) + copy(args, fake.getProcessSidecarsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetProcessSidecarsReturns(result1 []resources.Sidecar, result2 ccv3.Warnings, result3 error) { @@ -9251,14 +10667,17 @@ func (fake *FakeCloudControllerClient) GetProcessSidecarsReturnsOnCall(i int, re } func (fake *FakeCloudControllerClient) GetProcesses(arg1 ...ccv3.Query) ([]resources.Process, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getProcessesMutex.Lock() ret, specificReturn := fake.getProcessesReturnsOnCall[len(fake.getProcessesArgsForCall)] - fake.getProcessesArgsForCall = append(fake.getProcessesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getProcessesArgsForCall = append(fake.getProcessesArgsForCall, FakeCloudControllerClientGetProcessesArgs{arg1Copy}) stub := fake.GetProcessesStub fakeReturns := fake.getProcessesReturns - fake.recordInvocation("GetProcesses", []interface{}{arg1}) + fake.recordInvocation("GetProcesses", []interface{}{arg1Copy}) fake.getProcessesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9285,7 +10704,15 @@ func (fake *FakeCloudControllerClient) GetProcessesArgsForCall(i int) []ccv3.Que fake.getProcessesMutex.RLock() defer fake.getProcessesMutex.RUnlock() argsForCall := fake.getProcessesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetProcessesArgs() []FakeCloudControllerClientGetProcessesArgs { + fake.getProcessesMutex.RLock() + defer fake.getProcessesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetProcessesArgs, len(fake.getProcessesArgsForCall)) + copy(args, fake.getProcessesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) { @@ -9318,14 +10745,17 @@ func (fake *FakeCloudControllerClient) GetProcessesReturnsOnCall(i int, result1 } func (fake *FakeCloudControllerClient) GetRoles(arg1 ...ccv3.Query) ([]resources.Role, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getRolesMutex.Lock() ret, specificReturn := fake.getRolesReturnsOnCall[len(fake.getRolesArgsForCall)] - fake.getRolesArgsForCall = append(fake.getRolesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getRolesArgsForCall = append(fake.getRolesArgsForCall, FakeCloudControllerClientGetRolesArgs{arg1Copy}) stub := fake.GetRolesStub fakeReturns := fake.getRolesReturns - fake.recordInvocation("GetRoles", []interface{}{arg1}) + fake.recordInvocation("GetRoles", []interface{}{arg1Copy}) fake.getRolesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9352,7 +10782,15 @@ func (fake *FakeCloudControllerClient) GetRolesArgsForCall(i int) []ccv3.Query { fake.getRolesMutex.RLock() defer fake.getRolesMutex.RUnlock() argsForCall := fake.getRolesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetRolesArgs() []FakeCloudControllerClientGetRolesArgs { + fake.getRolesMutex.RLock() + defer fake.getRolesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRolesArgs, len(fake.getRolesArgsForCall)) + copy(args, fake.getRolesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRolesReturns(result1 []resources.Role, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -9390,8 +10828,7 @@ func (fake *FakeCloudControllerClient) GetRolesReturnsOnCall(i int, result1 []re func (fake *FakeCloudControllerClient) GetRoot() (ccv3.Root, ccv3.Warnings, error) { fake.getRootMutex.Lock() ret, specificReturn := fake.getRootReturnsOnCall[len(fake.getRootArgsForCall)] - fake.getRootArgsForCall = append(fake.getRootArgsForCall, struct { - }{}) + fake.getRootArgsForCall = append(fake.getRootArgsForCall, struct{}{}) stub := fake.GetRootStub fakeReturns := fake.getRootReturns fake.recordInvocation("GetRoot", []interface{}{}) @@ -9447,14 +10884,17 @@ func (fake *FakeCloudControllerClient) GetRootReturnsOnCall(i int, result1 ccv3. } func (fake *FakeCloudControllerClient) GetRouteBindings(arg1 ...ccv3.Query) ([]resources.RouteBinding, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getRouteBindingsMutex.Lock() ret, specificReturn := fake.getRouteBindingsReturnsOnCall[len(fake.getRouteBindingsArgsForCall)] - fake.getRouteBindingsArgsForCall = append(fake.getRouteBindingsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getRouteBindingsArgsForCall = append(fake.getRouteBindingsArgsForCall, FakeCloudControllerClientGetRouteBindingsArgs{arg1Copy}) stub := fake.GetRouteBindingsStub fakeReturns := fake.getRouteBindingsReturns - fake.recordInvocation("GetRouteBindings", []interface{}{arg1}) + fake.recordInvocation("GetRouteBindings", []interface{}{arg1Copy}) fake.getRouteBindingsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9481,7 +10921,15 @@ func (fake *FakeCloudControllerClient) GetRouteBindingsArgsForCall(i int) []ccv3 fake.getRouteBindingsMutex.RLock() defer fake.getRouteBindingsMutex.RUnlock() argsForCall := fake.getRouteBindingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetRouteBindingsArgs() []FakeCloudControllerClientGetRouteBindingsArgs { + fake.getRouteBindingsMutex.RLock() + defer fake.getRouteBindingsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRouteBindingsArgs, len(fake.getRouteBindingsArgsForCall)) + copy(args, fake.getRouteBindingsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRouteBindingsReturns(result1 []resources.RouteBinding, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -9519,9 +10967,7 @@ func (fake *FakeCloudControllerClient) GetRouteBindingsReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) GetRouteDestinations(arg1 string) ([]resources.RouteDestination, ccv3.Warnings, error) { fake.getRouteDestinationsMutex.Lock() ret, specificReturn := fake.getRouteDestinationsReturnsOnCall[len(fake.getRouteDestinationsArgsForCall)] - fake.getRouteDestinationsArgsForCall = append(fake.getRouteDestinationsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getRouteDestinationsArgsForCall = append(fake.getRouteDestinationsArgsForCall, FakeCloudControllerClientGetRouteDestinationsArgs{arg1}) stub := fake.GetRouteDestinationsStub fakeReturns := fake.getRouteDestinationsReturns fake.recordInvocation("GetRouteDestinations", []interface{}{arg1}) @@ -9551,7 +10997,15 @@ func (fake *FakeCloudControllerClient) GetRouteDestinationsArgsForCall(i int) st fake.getRouteDestinationsMutex.RLock() defer fake.getRouteDestinationsMutex.RUnlock() argsForCall := fake.getRouteDestinationsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetRouteDestinationsArgs() []FakeCloudControllerClientGetRouteDestinationsArgs { + fake.getRouteDestinationsMutex.RLock() + defer fake.getRouteDestinationsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRouteDestinationsArgs, len(fake.getRouteDestinationsArgsForCall)) + copy(args, fake.getRouteDestinationsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRouteDestinationsReturns(result1 []resources.RouteDestination, result2 ccv3.Warnings, result3 error) { @@ -9584,14 +11038,17 @@ func (fake *FakeCloudControllerClient) GetRouteDestinationsReturnsOnCall(i int, } func (fake *FakeCloudControllerClient) GetRoutePolicies(arg1 ...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getRoutePoliciesMutex.Lock() ret, specificReturn := fake.getRoutePoliciesReturnsOnCall[len(fake.getRoutePoliciesArgsForCall)] - fake.getRoutePoliciesArgsForCall = append(fake.getRoutePoliciesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getRoutePoliciesArgsForCall = append(fake.getRoutePoliciesArgsForCall, FakeCloudControllerClientGetRoutePoliciesArgs{arg1Copy}) stub := fake.GetRoutePoliciesStub fakeReturns := fake.getRoutePoliciesReturns - fake.recordInvocation("GetRoutePolicies", []interface{}{arg1}) + fake.recordInvocation("GetRoutePolicies", []interface{}{arg1Copy}) fake.getRoutePoliciesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9618,7 +11075,15 @@ func (fake *FakeCloudControllerClient) GetRoutePoliciesArgsForCall(i int) []ccv3 fake.getRoutePoliciesMutex.RLock() defer fake.getRoutePoliciesMutex.RUnlock() argsForCall := fake.getRoutePoliciesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesArgs() []FakeCloudControllerClientGetRoutePoliciesArgs { + fake.getRoutePoliciesMutex.RLock() + defer fake.getRoutePoliciesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRoutePoliciesArgs, len(fake.getRoutePoliciesArgsForCall)) + copy(args, fake.getRoutePoliciesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRoutePoliciesReturns(result1 []resources.RoutePolicy, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -9654,14 +11119,17 @@ func (fake *FakeCloudControllerClient) GetRoutePoliciesReturnsOnCall(i int, resu } func (fake *FakeCloudControllerClient) GetRoutes(arg1 ...ccv3.Query) ([]resources.Route, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getRoutesMutex.Lock() ret, specificReturn := fake.getRoutesReturnsOnCall[len(fake.getRoutesArgsForCall)] - fake.getRoutesArgsForCall = append(fake.getRoutesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getRoutesArgsForCall = append(fake.getRoutesArgsForCall, FakeCloudControllerClientGetRoutesArgs{arg1Copy}) stub := fake.GetRoutesStub fakeReturns := fake.getRoutesReturns - fake.recordInvocation("GetRoutes", []interface{}{arg1}) + fake.recordInvocation("GetRoutes", []interface{}{arg1Copy}) fake.getRoutesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9688,7 +11156,15 @@ func (fake *FakeCloudControllerClient) GetRoutesArgsForCall(i int) []ccv3.Query fake.getRoutesMutex.RLock() defer fake.getRoutesMutex.RUnlock() argsForCall := fake.getRoutesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetRoutesArgs() []FakeCloudControllerClientGetRoutesArgs { + fake.getRoutesMutex.RLock() + defer fake.getRoutesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRoutesArgs, len(fake.getRoutesArgsForCall)) + copy(args, fake.getRoutesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRoutesReturns(result1 []resources.Route, result2 ccv3.Warnings, result3 error) { @@ -9721,15 +11197,17 @@ func (fake *FakeCloudControllerClient) GetRoutesReturnsOnCall(i int, result1 []r } func (fake *FakeCloudControllerClient) GetRunningSecurityGroups(arg1 string, arg2 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getRunningSecurityGroupsMutex.Lock() ret, specificReturn := fake.getRunningSecurityGroupsReturnsOnCall[len(fake.getRunningSecurityGroupsArgsForCall)] - fake.getRunningSecurityGroupsArgsForCall = append(fake.getRunningSecurityGroupsArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getRunningSecurityGroupsArgsForCall = append(fake.getRunningSecurityGroupsArgsForCall, FakeCloudControllerClientGetRunningSecurityGroupsArgs{arg1, arg2Copy}) stub := fake.GetRunningSecurityGroupsStub fakeReturns := fake.getRunningSecurityGroupsReturns - fake.recordInvocation("GetRunningSecurityGroups", []interface{}{arg1, arg2}) + fake.recordInvocation("GetRunningSecurityGroups", []interface{}{arg1, arg2Copy}) fake.getRunningSecurityGroupsMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -9756,7 +11234,15 @@ func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsArgsForCall(i int fake.getRunningSecurityGroupsMutex.RLock() defer fake.getRunningSecurityGroupsMutex.RUnlock() argsForCall := fake.getRunningSecurityGroupsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsArgs() []FakeCloudControllerClientGetRunningSecurityGroupsArgs { + fake.getRunningSecurityGroupsMutex.RLock() + defer fake.getRunningSecurityGroupsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetRunningSecurityGroupsArgs, len(fake.getRunningSecurityGroupsArgsForCall)) + copy(args, fake.getRunningSecurityGroupsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) { @@ -9791,9 +11277,7 @@ func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsReturnsOnCall(i i func (fake *FakeCloudControllerClient) GetSSHEnabled(arg1 string) (ccv3.SSHEnabled, ccv3.Warnings, error) { fake.getSSHEnabledMutex.Lock() ret, specificReturn := fake.getSSHEnabledReturnsOnCall[len(fake.getSSHEnabledArgsForCall)] - fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, FakeCloudControllerClientGetSSHEnabledArgs{arg1}) stub := fake.GetSSHEnabledStub fakeReturns := fake.getSSHEnabledReturns fake.recordInvocation("GetSSHEnabled", []interface{}{arg1}) @@ -9823,7 +11307,15 @@ func (fake *FakeCloudControllerClient) GetSSHEnabledArgsForCall(i int) string { fake.getSSHEnabledMutex.RLock() defer fake.getSSHEnabledMutex.RUnlock() argsForCall := fake.getSSHEnabledArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSSHEnabledArgs() []FakeCloudControllerClientGetSSHEnabledArgs { + fake.getSSHEnabledMutex.RLock() + defer fake.getSSHEnabledMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSSHEnabledArgs, len(fake.getSSHEnabledArgsForCall)) + copy(args, fake.getSSHEnabledArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSSHEnabledReturns(result1 ccv3.SSHEnabled, result2 ccv3.Warnings, result3 error) { @@ -9856,14 +11348,17 @@ func (fake *FakeCloudControllerClient) GetSSHEnabledReturnsOnCall(i int, result1 } func (fake *FakeCloudControllerClient) GetSecurityGroups(arg1 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getSecurityGroupsMutex.Lock() ret, specificReturn := fake.getSecurityGroupsReturnsOnCall[len(fake.getSecurityGroupsArgsForCall)] - fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, FakeCloudControllerClientGetSecurityGroupsArgs{arg1Copy}) stub := fake.GetSecurityGroupsStub fakeReturns := fake.getSecurityGroupsReturns - fake.recordInvocation("GetSecurityGroups", []interface{}{arg1}) + fake.recordInvocation("GetSecurityGroups", []interface{}{arg1Copy}) fake.getSecurityGroupsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9890,7 +11385,15 @@ func (fake *FakeCloudControllerClient) GetSecurityGroupsArgsForCall(i int) []ccv fake.getSecurityGroupsMutex.RLock() defer fake.getSecurityGroupsMutex.RUnlock() argsForCall := fake.getSecurityGroupsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSecurityGroupsArgs() []FakeCloudControllerClientGetSecurityGroupsArgs { + fake.getSecurityGroupsMutex.RLock() + defer fake.getSecurityGroupsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSecurityGroupsArgs, len(fake.getSecurityGroupsArgsForCall)) + copy(args, fake.getSecurityGroupsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) { @@ -9922,15 +11425,169 @@ func (fake *FakeCloudControllerClient) GetSecurityGroupsReturnsOnCall(i int, res }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) GetServiceAccount(arg1 string) (resources.ServiceAccount, ccv3.Warnings, error) { + fake.getServiceAccountMutex.Lock() + ret, specificReturn := fake.getServiceAccountReturnsOnCall[len(fake.getServiceAccountArgsForCall)] + fake.getServiceAccountArgsForCall = append(fake.getServiceAccountArgsForCall, FakeCloudControllerClientGetServiceAccountArgs{arg1}) + stub := fake.GetServiceAccountStub + fakeReturns := fake.getServiceAccountReturns + fake.recordInvocation("GetServiceAccount", []interface{}{arg1}) + fake.getServiceAccountMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) GetServiceAccountCallCount() int { + fake.getServiceAccountMutex.RLock() + defer fake.getServiceAccountMutex.RUnlock() + return len(fake.getServiceAccountArgsForCall) +} + +func (fake *FakeCloudControllerClient) GetServiceAccountCalls(stub func(string) (resources.ServiceAccount, ccv3.Warnings, error)) { + fake.getServiceAccountMutex.Lock() + defer fake.getServiceAccountMutex.Unlock() + fake.GetServiceAccountStub = stub +} + +func (fake *FakeCloudControllerClient) GetServiceAccountArgsForCall(i int) string { + fake.getServiceAccountMutex.RLock() + defer fake.getServiceAccountMutex.RUnlock() + argsForCall := fake.getServiceAccountArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceAccountArgs() []FakeCloudControllerClientGetServiceAccountArgs { + fake.getServiceAccountMutex.RLock() + defer fake.getServiceAccountMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceAccountArgs, len(fake.getServiceAccountArgsForCall)) + copy(args, fake.getServiceAccountArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) GetServiceAccountReturns(result1 resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.getServiceAccountMutex.Lock() + defer fake.getServiceAccountMutex.Unlock() + fake.GetServiceAccountStub = nil + fake.getServiceAccountReturns = struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) GetServiceAccountReturnsOnCall(i int, result1 resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.getServiceAccountMutex.Lock() + defer fake.getServiceAccountMutex.Unlock() + fake.GetServiceAccountStub = nil + if fake.getServiceAccountReturnsOnCall == nil { + fake.getServiceAccountReturnsOnCall = make(map[int]struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }) + } + fake.getServiceAccountReturnsOnCall[i] = struct { + result1 resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) GetServiceAccounts(arg1 ...ccv3.Query) ([]resources.ServiceAccount, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } + fake.getServiceAccountsMutex.Lock() + ret, specificReturn := fake.getServiceAccountsReturnsOnCall[len(fake.getServiceAccountsArgsForCall)] + fake.getServiceAccountsArgsForCall = append(fake.getServiceAccountsArgsForCall, FakeCloudControllerClientGetServiceAccountsArgs{arg1Copy}) + stub := fake.GetServiceAccountsStub + fakeReturns := fake.getServiceAccountsReturns + fake.recordInvocation("GetServiceAccounts", []interface{}{arg1Copy}) + fake.getServiceAccountsMutex.Unlock() + if stub != nil { + return stub(arg1...) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsCallCount() int { + fake.getServiceAccountsMutex.RLock() + defer fake.getServiceAccountsMutex.RUnlock() + return len(fake.getServiceAccountsArgsForCall) +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsCalls(stub func(...ccv3.Query) ([]resources.ServiceAccount, ccv3.Warnings, error)) { + fake.getServiceAccountsMutex.Lock() + defer fake.getServiceAccountsMutex.Unlock() + fake.GetServiceAccountsStub = stub +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsArgsForCall(i int) []ccv3.Query { + fake.getServiceAccountsMutex.RLock() + defer fake.getServiceAccountsMutex.RUnlock() + argsForCall := fake.getServiceAccountsArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsArgs() []FakeCloudControllerClientGetServiceAccountsArgs { + fake.getServiceAccountsMutex.RLock() + defer fake.getServiceAccountsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceAccountsArgs, len(fake.getServiceAccountsArgsForCall)) + copy(args, fake.getServiceAccountsArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsReturns(result1 []resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.getServiceAccountsMutex.Lock() + defer fake.getServiceAccountsMutex.Unlock() + fake.GetServiceAccountsStub = nil + fake.getServiceAccountsReturns = struct { + result1 []resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) GetServiceAccountsReturnsOnCall(i int, result1 []resources.ServiceAccount, result2 ccv3.Warnings, result3 error) { + fake.getServiceAccountsMutex.Lock() + defer fake.getServiceAccountsMutex.Unlock() + fake.GetServiceAccountsStub = nil + if fake.getServiceAccountsReturnsOnCall == nil { + fake.getServiceAccountsReturnsOnCall = make(map[int]struct { + result1 []resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }) + } + fake.getServiceAccountsReturnsOnCall[i] = struct { + result1 []resources.ServiceAccount + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) GetServiceBrokers(arg1 ...ccv3.Query) ([]resources.ServiceBroker, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServiceBrokersMutex.Lock() ret, specificReturn := fake.getServiceBrokersReturnsOnCall[len(fake.getServiceBrokersArgsForCall)] - fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, FakeCloudControllerClientGetServiceBrokersArgs{arg1Copy}) stub := fake.GetServiceBrokersStub fakeReturns := fake.getServiceBrokersReturns - fake.recordInvocation("GetServiceBrokers", []interface{}{arg1}) + fake.recordInvocation("GetServiceBrokers", []interface{}{arg1Copy}) fake.getServiceBrokersMutex.Unlock() if stub != nil { return stub(arg1...) @@ -9957,7 +11614,15 @@ func (fake *FakeCloudControllerClient) GetServiceBrokersArgsForCall(i int) []ccv fake.getServiceBrokersMutex.RLock() defer fake.getServiceBrokersMutex.RUnlock() argsForCall := fake.getServiceBrokersArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceBrokersArgs() []FakeCloudControllerClientGetServiceBrokersArgs { + fake.getServiceBrokersMutex.RLock() + defer fake.getServiceBrokersMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceBrokersArgs, len(fake.getServiceBrokersArgsForCall)) + copy(args, fake.getServiceBrokersArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceBrokersReturns(result1 []resources.ServiceBroker, result2 ccv3.Warnings, result3 error) { @@ -9992,9 +11657,7 @@ func (fake *FakeCloudControllerClient) GetServiceBrokersReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetails(arg1 string) (resources.ServiceCredentialBindingDetails, ccv3.Warnings, error) { fake.getServiceCredentialBindingDetailsMutex.Lock() ret, specificReturn := fake.getServiceCredentialBindingDetailsReturnsOnCall[len(fake.getServiceCredentialBindingDetailsArgsForCall)] - fake.getServiceCredentialBindingDetailsArgsForCall = append(fake.getServiceCredentialBindingDetailsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceCredentialBindingDetailsArgsForCall = append(fake.getServiceCredentialBindingDetailsArgsForCall, FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs{arg1}) stub := fake.GetServiceCredentialBindingDetailsStub fakeReturns := fake.getServiceCredentialBindingDetailsReturns fake.recordInvocation("GetServiceCredentialBindingDetails", []interface{}{arg1}) @@ -10024,7 +11687,15 @@ func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsArgsFor fake.getServiceCredentialBindingDetailsMutex.RLock() defer fake.getServiceCredentialBindingDetailsMutex.RUnlock() argsForCall := fake.getServiceCredentialBindingDetailsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsArgs() []FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs { + fake.getServiceCredentialBindingDetailsMutex.RLock() + defer fake.getServiceCredentialBindingDetailsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceCredentialBindingDetailsArgs, len(fake.getServiceCredentialBindingDetailsArgsForCall)) + copy(args, fake.getServiceCredentialBindingDetailsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsReturns(result1 resources.ServiceCredentialBindingDetails, result2 ccv3.Warnings, result3 error) { @@ -10057,14 +11728,17 @@ func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsReturns } func (fake *FakeCloudControllerClient) GetServiceCredentialBindings(arg1 ...ccv3.Query) ([]resources.ServiceCredentialBinding, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServiceCredentialBindingsMutex.Lock() ret, specificReturn := fake.getServiceCredentialBindingsReturnsOnCall[len(fake.getServiceCredentialBindingsArgsForCall)] - fake.getServiceCredentialBindingsArgsForCall = append(fake.getServiceCredentialBindingsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServiceCredentialBindingsArgsForCall = append(fake.getServiceCredentialBindingsArgsForCall, FakeCloudControllerClientGetServiceCredentialBindingsArgs{arg1Copy}) stub := fake.GetServiceCredentialBindingsStub fakeReturns := fake.getServiceCredentialBindingsReturns - fake.recordInvocation("GetServiceCredentialBindings", []interface{}{arg1}) + fake.recordInvocation("GetServiceCredentialBindings", []interface{}{arg1Copy}) fake.getServiceCredentialBindingsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -10091,7 +11765,15 @@ func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsArgsForCall(i fake.getServiceCredentialBindingsMutex.RLock() defer fake.getServiceCredentialBindingsMutex.RUnlock() argsForCall := fake.getServiceCredentialBindingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsArgs() []FakeCloudControllerClientGetServiceCredentialBindingsArgs { + fake.getServiceCredentialBindingsMutex.RLock() + defer fake.getServiceCredentialBindingsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceCredentialBindingsArgs, len(fake.getServiceCredentialBindingsArgsForCall)) + copy(args, fake.getServiceCredentialBindingsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsReturns(result1 []resources.ServiceCredentialBinding, result2 ccv3.Warnings, result3 error) { @@ -10126,9 +11808,7 @@ func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsReturnsOnCall func (fake *FakeCloudControllerClient) GetServiceInstanceByGUID(arg1 string) (resources.ServiceInstance, ccv3.Warnings, error) { fake.getServiceInstanceByGUIDMutex.Lock() ret, specificReturn := fake.getServiceInstanceByGUIDReturnsOnCall[len(fake.getServiceInstanceByGUIDArgsForCall)] - fake.getServiceInstanceByGUIDArgsForCall = append(fake.getServiceInstanceByGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceInstanceByGUIDArgsForCall = append(fake.getServiceInstanceByGUIDArgsForCall, FakeCloudControllerClientGetServiceInstanceByGUIDArgs{arg1}) stub := fake.GetServiceInstanceByGUIDStub fakeReturns := fake.getServiceInstanceByGUIDReturns fake.recordInvocation("GetServiceInstanceByGUID", []interface{}{arg1}) @@ -10158,7 +11838,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceByGUIDArgsForCall(i int fake.getServiceInstanceByGUIDMutex.RLock() defer fake.getServiceInstanceByGUIDMutex.RUnlock() argsForCall := fake.getServiceInstanceByGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceInstanceByGUIDArgs() []FakeCloudControllerClientGetServiceInstanceByGUIDArgs { + fake.getServiceInstanceByGUIDMutex.RLock() + defer fake.getServiceInstanceByGUIDMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstanceByGUIDArgs, len(fake.getServiceInstanceByGUIDArgsForCall)) + copy(args, fake.getServiceInstanceByGUIDArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstanceByGUIDReturns(result1 resources.ServiceInstance, result2 ccv3.Warnings, result3 error) { @@ -10191,16 +11879,17 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceByGUIDReturnsOnCall(i i } func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpace(arg1 string, arg2 string, arg3 ...ccv3.Query) (resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg3Copy []ccv3.Query + if arg3 != nil { + arg3Copy = make([]ccv3.Query, len(arg3)) + copy(arg3Copy, arg3) + } fake.getServiceInstanceByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getServiceInstanceByNameAndSpaceReturnsOnCall[len(fake.getServiceInstanceByNameAndSpaceArgsForCall)] - fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 []ccv3.Query - }{arg1, arg2, arg3}) + fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs{arg1, arg2, arg3Copy}) stub := fake.GetServiceInstanceByNameAndSpaceStub fakeReturns := fake.getServiceInstanceByNameAndSpaceReturns - fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2, arg3Copy}) fake.getServiceInstanceByNameAndSpaceMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -10227,7 +11916,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceArgsForCa fake.getServiceInstanceByNameAndSpaceMutex.RLock() defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock() argsForCall := fake.getServiceInstanceByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceArgs() []FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs { + fake.getServiceInstanceByNameAndSpaceMutex.RLock() + defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstanceByNameAndSpaceArgs, len(fake.getServiceInstanceByNameAndSpaceArgsForCall)) + copy(args, fake.getServiceInstanceByNameAndSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceReturns(result1 resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -10265,9 +11962,7 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceReturnsOn func (fake *FakeCloudControllerClient) GetServiceInstanceParameters(arg1 string) (types.JSONObject, ccv3.Warnings, error) { fake.getServiceInstanceParametersMutex.Lock() ret, specificReturn := fake.getServiceInstanceParametersReturnsOnCall[len(fake.getServiceInstanceParametersArgsForCall)] - fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, FakeCloudControllerClientGetServiceInstanceParametersArgs{arg1}) stub := fake.GetServiceInstanceParametersStub fakeReturns := fake.getServiceInstanceParametersReturns fake.recordInvocation("GetServiceInstanceParameters", []interface{}{arg1}) @@ -10297,7 +11992,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceParametersArgsForCall(i fake.getServiceInstanceParametersMutex.RLock() defer fake.getServiceInstanceParametersMutex.RUnlock() argsForCall := fake.getServiceInstanceParametersArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceInstanceParametersArgs() []FakeCloudControllerClientGetServiceInstanceParametersArgs { + fake.getServiceInstanceParametersMutex.RLock() + defer fake.getServiceInstanceParametersMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstanceParametersArgs, len(fake.getServiceInstanceParametersArgsForCall)) + copy(args, fake.getServiceInstanceParametersArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstanceParametersReturns(result1 types.JSONObject, result2 ccv3.Warnings, result3 error) { @@ -10332,9 +12035,7 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceParametersReturnsOnCall func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpaces(arg1 string) ([]ccv3.SpaceWithOrganization, ccv3.Warnings, error) { fake.getServiceInstanceSharedSpacesMutex.Lock() ret, specificReturn := fake.getServiceInstanceSharedSpacesReturnsOnCall[len(fake.getServiceInstanceSharedSpacesArgsForCall)] - fake.getServiceInstanceSharedSpacesArgsForCall = append(fake.getServiceInstanceSharedSpacesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceInstanceSharedSpacesArgsForCall = append(fake.getServiceInstanceSharedSpacesArgsForCall, FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs{arg1}) stub := fake.GetServiceInstanceSharedSpacesStub fakeReturns := fake.getServiceInstanceSharedSpacesReturns fake.recordInvocation("GetServiceInstanceSharedSpaces", []interface{}{arg1}) @@ -10364,7 +12065,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesArgsForCall fake.getServiceInstanceSharedSpacesMutex.RLock() defer fake.getServiceInstanceSharedSpacesMutex.RUnlock() argsForCall := fake.getServiceInstanceSharedSpacesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesArgs() []FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs { + fake.getServiceInstanceSharedSpacesMutex.RLock() + defer fake.getServiceInstanceSharedSpacesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstanceSharedSpacesArgs, len(fake.getServiceInstanceSharedSpacesArgsForCall)) + copy(args, fake.getServiceInstanceSharedSpacesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesReturns(result1 []ccv3.SpaceWithOrganization, result2 ccv3.Warnings, result3 error) { @@ -10399,9 +12108,7 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesReturnsOnCa func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummary(arg1 string) ([]resources.ServiceInstanceUsageSummary, ccv3.Warnings, error) { fake.getServiceInstanceUsageSummaryMutex.Lock() ret, specificReturn := fake.getServiceInstanceUsageSummaryReturnsOnCall[len(fake.getServiceInstanceUsageSummaryArgsForCall)] - fake.getServiceInstanceUsageSummaryArgsForCall = append(fake.getServiceInstanceUsageSummaryArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceInstanceUsageSummaryArgsForCall = append(fake.getServiceInstanceUsageSummaryArgsForCall, FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs{arg1}) stub := fake.GetServiceInstanceUsageSummaryStub fakeReturns := fake.getServiceInstanceUsageSummaryReturns fake.recordInvocation("GetServiceInstanceUsageSummary", []interface{}{arg1}) @@ -10431,7 +12138,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryArgsForCall fake.getServiceInstanceUsageSummaryMutex.RLock() defer fake.getServiceInstanceUsageSummaryMutex.RUnlock() argsForCall := fake.getServiceInstanceUsageSummaryArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryArgs() []FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs { + fake.getServiceInstanceUsageSummaryMutex.RLock() + defer fake.getServiceInstanceUsageSummaryMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstanceUsageSummaryArgs, len(fake.getServiceInstanceUsageSummaryArgsForCall)) + copy(args, fake.getServiceInstanceUsageSummaryArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryReturns(result1 []resources.ServiceInstanceUsageSummary, result2 ccv3.Warnings, result3 error) { @@ -10464,14 +12179,17 @@ func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryReturnsOnCa } func (fake *FakeCloudControllerClient) GetServiceInstances(arg1 ...ccv3.Query) ([]resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServiceInstancesMutex.Lock() ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)] - fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, FakeCloudControllerClientGetServiceInstancesArgs{arg1Copy}) stub := fake.GetServiceInstancesStub fakeReturns := fake.getServiceInstancesReturns - fake.recordInvocation("GetServiceInstances", []interface{}{arg1}) + fake.recordInvocation("GetServiceInstances", []interface{}{arg1Copy}) fake.getServiceInstancesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -10498,7 +12216,15 @@ func (fake *FakeCloudControllerClient) GetServiceInstancesArgsForCall(i int) []c fake.getServiceInstancesMutex.RLock() defer fake.getServiceInstancesMutex.RUnlock() argsForCall := fake.getServiceInstancesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceInstancesArgs() []FakeCloudControllerClientGetServiceInstancesArgs { + fake.getServiceInstancesMutex.RLock() + defer fake.getServiceInstancesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceInstancesArgs, len(fake.getServiceInstancesArgsForCall)) + copy(args, fake.getServiceInstancesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceInstancesReturns(result1 []resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -10536,9 +12262,7 @@ func (fake *FakeCloudControllerClient) GetServiceInstancesReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) GetServiceOfferingByGUID(arg1 string) (resources.ServiceOffering, ccv3.Warnings, error) { fake.getServiceOfferingByGUIDMutex.Lock() ret, specificReturn := fake.getServiceOfferingByGUIDReturnsOnCall[len(fake.getServiceOfferingByGUIDArgsForCall)] - fake.getServiceOfferingByGUIDArgsForCall = append(fake.getServiceOfferingByGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceOfferingByGUIDArgsForCall = append(fake.getServiceOfferingByGUIDArgsForCall, FakeCloudControllerClientGetServiceOfferingByGUIDArgs{arg1}) stub := fake.GetServiceOfferingByGUIDStub fakeReturns := fake.getServiceOfferingByGUIDReturns fake.recordInvocation("GetServiceOfferingByGUID", []interface{}{arg1}) @@ -10568,7 +12292,15 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDArgsForCall(i int fake.getServiceOfferingByGUIDMutex.RLock() defer fake.getServiceOfferingByGUIDMutex.RUnlock() argsForCall := fake.getServiceOfferingByGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDArgs() []FakeCloudControllerClientGetServiceOfferingByGUIDArgs { + fake.getServiceOfferingByGUIDMutex.RLock() + defer fake.getServiceOfferingByGUIDMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceOfferingByGUIDArgs, len(fake.getServiceOfferingByGUIDArgsForCall)) + copy(args, fake.getServiceOfferingByGUIDArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDReturns(result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) { @@ -10603,10 +12335,7 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDReturnsOnCall(i i func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBroker(arg1 string, arg2 string) (resources.ServiceOffering, ccv3.Warnings, error) { fake.getServiceOfferingByNameAndBrokerMutex.Lock() ret, specificReturn := fake.getServiceOfferingByNameAndBrokerReturnsOnCall[len(fake.getServiceOfferingByNameAndBrokerArgsForCall)] - fake.getServiceOfferingByNameAndBrokerArgsForCall = append(fake.getServiceOfferingByNameAndBrokerArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceOfferingByNameAndBrokerArgsForCall = append(fake.getServiceOfferingByNameAndBrokerArgsForCall, FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs{arg1, arg2}) stub := fake.GetServiceOfferingByNameAndBrokerStub fakeReturns := fake.getServiceOfferingByNameAndBrokerReturns fake.recordInvocation("GetServiceOfferingByNameAndBroker", []interface{}{arg1, arg2}) @@ -10636,7 +12365,15 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerArgsForC fake.getServiceOfferingByNameAndBrokerMutex.RLock() defer fake.getServiceOfferingByNameAndBrokerMutex.RUnlock() argsForCall := fake.getServiceOfferingByNameAndBrokerArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerArgs() []FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs { + fake.getServiceOfferingByNameAndBrokerMutex.RLock() + defer fake.getServiceOfferingByNameAndBrokerMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceOfferingByNameAndBrokerArgs, len(fake.getServiceOfferingByNameAndBrokerArgsForCall)) + copy(args, fake.getServiceOfferingByNameAndBrokerArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerReturns(result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) { @@ -10669,14 +12406,17 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerReturnsO } func (fake *FakeCloudControllerClient) GetServiceOfferings(arg1 ...ccv3.Query) ([]resources.ServiceOffering, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServiceOfferingsMutex.Lock() ret, specificReturn := fake.getServiceOfferingsReturnsOnCall[len(fake.getServiceOfferingsArgsForCall)] - fake.getServiceOfferingsArgsForCall = append(fake.getServiceOfferingsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServiceOfferingsArgsForCall = append(fake.getServiceOfferingsArgsForCall, FakeCloudControllerClientGetServiceOfferingsArgs{arg1Copy}) stub := fake.GetServiceOfferingsStub fakeReturns := fake.getServiceOfferingsReturns - fake.recordInvocation("GetServiceOfferings", []interface{}{arg1}) + fake.recordInvocation("GetServiceOfferings", []interface{}{arg1Copy}) fake.getServiceOfferingsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -10703,7 +12443,15 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingsArgsForCall(i int) []c fake.getServiceOfferingsMutex.RLock() defer fake.getServiceOfferingsMutex.RUnlock() argsForCall := fake.getServiceOfferingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServiceOfferingsArgs() []FakeCloudControllerClientGetServiceOfferingsArgs { + fake.getServiceOfferingsMutex.RLock() + defer fake.getServiceOfferingsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServiceOfferingsArgs, len(fake.getServiceOfferingsArgsForCall)) + copy(args, fake.getServiceOfferingsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServiceOfferingsReturns(result1 []resources.ServiceOffering, result2 ccv3.Warnings, result3 error) { @@ -10738,9 +12486,7 @@ func (fake *FakeCloudControllerClient) GetServiceOfferingsReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) GetServicePlanByGUID(arg1 string) (resources.ServicePlan, ccv3.Warnings, error) { fake.getServicePlanByGUIDMutex.Lock() ret, specificReturn := fake.getServicePlanByGUIDReturnsOnCall[len(fake.getServicePlanByGUIDArgsForCall)] - fake.getServicePlanByGUIDArgsForCall = append(fake.getServicePlanByGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServicePlanByGUIDArgsForCall = append(fake.getServicePlanByGUIDArgsForCall, FakeCloudControllerClientGetServicePlanByGUIDArgs{arg1}) stub := fake.GetServicePlanByGUIDStub fakeReturns := fake.getServicePlanByGUIDReturns fake.recordInvocation("GetServicePlanByGUID", []interface{}{arg1}) @@ -10770,7 +12516,15 @@ func (fake *FakeCloudControllerClient) GetServicePlanByGUIDArgsForCall(i int) st fake.getServicePlanByGUIDMutex.RLock() defer fake.getServicePlanByGUIDMutex.RUnlock() argsForCall := fake.getServicePlanByGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServicePlanByGUIDArgs() []FakeCloudControllerClientGetServicePlanByGUIDArgs { + fake.getServicePlanByGUIDMutex.RLock() + defer fake.getServicePlanByGUIDMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServicePlanByGUIDArgs, len(fake.getServicePlanByGUIDArgsForCall)) + copy(args, fake.getServicePlanByGUIDArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServicePlanByGUIDReturns(result1 resources.ServicePlan, result2 ccv3.Warnings, result3 error) { @@ -10805,9 +12559,7 @@ func (fake *FakeCloudControllerClient) GetServicePlanByGUIDReturnsOnCall(i int, func (fake *FakeCloudControllerClient) GetServicePlanVisibility(arg1 string) (resources.ServicePlanVisibility, ccv3.Warnings, error) { fake.getServicePlanVisibilityMutex.Lock() ret, specificReturn := fake.getServicePlanVisibilityReturnsOnCall[len(fake.getServicePlanVisibilityArgsForCall)] - fake.getServicePlanVisibilityArgsForCall = append(fake.getServicePlanVisibilityArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServicePlanVisibilityArgsForCall = append(fake.getServicePlanVisibilityArgsForCall, FakeCloudControllerClientGetServicePlanVisibilityArgs{arg1}) stub := fake.GetServicePlanVisibilityStub fakeReturns := fake.getServicePlanVisibilityReturns fake.recordInvocation("GetServicePlanVisibility", []interface{}{arg1}) @@ -10837,7 +12589,15 @@ func (fake *FakeCloudControllerClient) GetServicePlanVisibilityArgsForCall(i int fake.getServicePlanVisibilityMutex.RLock() defer fake.getServicePlanVisibilityMutex.RUnlock() argsForCall := fake.getServicePlanVisibilityArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServicePlanVisibilityArgs() []FakeCloudControllerClientGetServicePlanVisibilityArgs { + fake.getServicePlanVisibilityMutex.RLock() + defer fake.getServicePlanVisibilityMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServicePlanVisibilityArgs, len(fake.getServicePlanVisibilityArgsForCall)) + copy(args, fake.getServicePlanVisibilityArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServicePlanVisibilityReturns(result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) { @@ -10870,14 +12630,17 @@ func (fake *FakeCloudControllerClient) GetServicePlanVisibilityReturnsOnCall(i i } func (fake *FakeCloudControllerClient) GetServicePlans(arg1 ...ccv3.Query) ([]resources.ServicePlan, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServicePlansMutex.Lock() ret, specificReturn := fake.getServicePlansReturnsOnCall[len(fake.getServicePlansArgsForCall)] - fake.getServicePlansArgsForCall = append(fake.getServicePlansArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServicePlansArgsForCall = append(fake.getServicePlansArgsForCall, FakeCloudControllerClientGetServicePlansArgs{arg1Copy}) stub := fake.GetServicePlansStub fakeReturns := fake.getServicePlansReturns - fake.recordInvocation("GetServicePlans", []interface{}{arg1}) + fake.recordInvocation("GetServicePlans", []interface{}{arg1Copy}) fake.getServicePlansMutex.Unlock() if stub != nil { return stub(arg1...) @@ -10904,7 +12667,15 @@ func (fake *FakeCloudControllerClient) GetServicePlansArgsForCall(i int) []ccv3. fake.getServicePlansMutex.RLock() defer fake.getServicePlansMutex.RUnlock() argsForCall := fake.getServicePlansArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServicePlansArgs() []FakeCloudControllerClientGetServicePlansArgs { + fake.getServicePlansMutex.RLock() + defer fake.getServicePlansMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServicePlansArgs, len(fake.getServicePlansArgsForCall)) + copy(args, fake.getServicePlansArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServicePlansReturns(result1 []resources.ServicePlan, result2 ccv3.Warnings, result3 error) { @@ -10937,14 +12708,17 @@ func (fake *FakeCloudControllerClient) GetServicePlansReturnsOnCall(i int, resul } func (fake *FakeCloudControllerClient) GetServicePlansWithOfferings(arg1 ...ccv3.Query) ([]ccv3.ServiceOfferingWithPlans, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServicePlansWithOfferingsMutex.Lock() ret, specificReturn := fake.getServicePlansWithOfferingsReturnsOnCall[len(fake.getServicePlansWithOfferingsArgsForCall)] - fake.getServicePlansWithOfferingsArgsForCall = append(fake.getServicePlansWithOfferingsArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServicePlansWithOfferingsArgsForCall = append(fake.getServicePlansWithOfferingsArgsForCall, FakeCloudControllerClientGetServicePlansWithOfferingsArgs{arg1Copy}) stub := fake.GetServicePlansWithOfferingsStub fakeReturns := fake.getServicePlansWithOfferingsReturns - fake.recordInvocation("GetServicePlansWithOfferings", []interface{}{arg1}) + fake.recordInvocation("GetServicePlansWithOfferings", []interface{}{arg1Copy}) fake.getServicePlansWithOfferingsMutex.Unlock() if stub != nil { return stub(arg1...) @@ -10971,7 +12745,15 @@ func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsArgsForCall(i fake.getServicePlansWithOfferingsMutex.RLock() defer fake.getServicePlansWithOfferingsMutex.RUnlock() argsForCall := fake.getServicePlansWithOfferingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsArgs() []FakeCloudControllerClientGetServicePlansWithOfferingsArgs { + fake.getServicePlansWithOfferingsMutex.RLock() + defer fake.getServicePlansWithOfferingsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServicePlansWithOfferingsArgs, len(fake.getServicePlansWithOfferingsArgsForCall)) + copy(args, fake.getServicePlansWithOfferingsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsReturns(result1 []ccv3.ServiceOfferingWithPlans, result2 ccv3.Warnings, result3 error) { @@ -11004,14 +12786,17 @@ func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsReturnsOnCall } func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganization(arg1 ...ccv3.Query) ([]ccv3.ServicePlanWithSpaceAndOrganization, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getServicePlansWithSpaceAndOrganizationMutex.Lock() ret, specificReturn := fake.getServicePlansWithSpaceAndOrganizationReturnsOnCall[len(fake.getServicePlansWithSpaceAndOrganizationArgsForCall)] - fake.getServicePlansWithSpaceAndOrganizationArgsForCall = append(fake.getServicePlansWithSpaceAndOrganizationArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getServicePlansWithSpaceAndOrganizationArgsForCall = append(fake.getServicePlansWithSpaceAndOrganizationArgsForCall, FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs{arg1Copy}) stub := fake.GetServicePlansWithSpaceAndOrganizationStub fakeReturns := fake.getServicePlansWithSpaceAndOrganizationReturns - fake.recordInvocation("GetServicePlansWithSpaceAndOrganization", []interface{}{arg1}) + fake.recordInvocation("GetServicePlansWithSpaceAndOrganization", []interface{}{arg1Copy}) fake.getServicePlansWithSpaceAndOrganizationMutex.Unlock() if stub != nil { return stub(arg1...) @@ -11038,7 +12823,15 @@ func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationAr fake.getServicePlansWithSpaceAndOrganizationMutex.RLock() defer fake.getServicePlansWithSpaceAndOrganizationMutex.RUnlock() argsForCall := fake.getServicePlansWithSpaceAndOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationArgs() []FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs { + fake.getServicePlansWithSpaceAndOrganizationMutex.RLock() + defer fake.getServicePlansWithSpaceAndOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientGetServicePlansWithSpaceAndOrganizationArgs, len(fake.getServicePlansWithSpaceAndOrganizationArgsForCall)) + copy(args, fake.getServicePlansWithSpaceAndOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationReturns(result1 []ccv3.ServicePlanWithSpaceAndOrganization, result2 ccv3.Warnings, result3 error) { @@ -11073,10 +12866,7 @@ func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationRe func (fake *FakeCloudControllerClient) GetSpaceFeature(arg1 string, arg2 string) (bool, ccv3.Warnings, error) { fake.getSpaceFeatureMutex.Lock() ret, specificReturn := fake.getSpaceFeatureReturnsOnCall[len(fake.getSpaceFeatureArgsForCall)] - fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, FakeCloudControllerClientGetSpaceFeatureArgs{arg1, arg2}) stub := fake.GetSpaceFeatureStub fakeReturns := fake.getSpaceFeatureReturns fake.recordInvocation("GetSpaceFeature", []interface{}{arg1, arg2}) @@ -11106,7 +12896,15 @@ func (fake *FakeCloudControllerClient) GetSpaceFeatureArgsForCall(i int) (string fake.getSpaceFeatureMutex.RLock() defer fake.getSpaceFeatureMutex.RUnlock() argsForCall := fake.getSpaceFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetSpaceFeatureArgs() []FakeCloudControllerClientGetSpaceFeatureArgs { + fake.getSpaceFeatureMutex.RLock() + defer fake.getSpaceFeatureMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpaceFeatureArgs, len(fake.getSpaceFeatureArgsForCall)) + copy(args, fake.getSpaceFeatureArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpaceFeatureReturns(result1 bool, result2 ccv3.Warnings, result3 error) { @@ -11141,9 +12939,7 @@ func (fake *FakeCloudControllerClient) GetSpaceFeatureReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) GetSpaceIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) { fake.getSpaceIsolationSegmentMutex.Lock() ret, specificReturn := fake.getSpaceIsolationSegmentReturnsOnCall[len(fake.getSpaceIsolationSegmentArgsForCall)] - fake.getSpaceIsolationSegmentArgsForCall = append(fake.getSpaceIsolationSegmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSpaceIsolationSegmentArgsForCall = append(fake.getSpaceIsolationSegmentArgsForCall, FakeCloudControllerClientGetSpaceIsolationSegmentArgs{arg1}) stub := fake.GetSpaceIsolationSegmentStub fakeReturns := fake.getSpaceIsolationSegmentReturns fake.recordInvocation("GetSpaceIsolationSegment", []interface{}{arg1}) @@ -11173,7 +12969,15 @@ func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentArgsForCall(i int fake.getSpaceIsolationSegmentMutex.RLock() defer fake.getSpaceIsolationSegmentMutex.RUnlock() argsForCall := fake.getSpaceIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentArgs() []FakeCloudControllerClientGetSpaceIsolationSegmentArgs { + fake.getSpaceIsolationSegmentMutex.RLock() + defer fake.getSpaceIsolationSegmentMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpaceIsolationSegmentArgs, len(fake.getSpaceIsolationSegmentArgsForCall)) + copy(args, fake.getSpaceIsolationSegmentArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) { @@ -11213,10 +13017,7 @@ func (fake *FakeCloudControllerClient) GetSpaceManifestDiff(arg1 string, arg2 [] } fake.getSpaceManifestDiffMutex.Lock() ret, specificReturn := fake.getSpaceManifestDiffReturnsOnCall[len(fake.getSpaceManifestDiffArgsForCall)] - fake.getSpaceManifestDiffArgsForCall = append(fake.getSpaceManifestDiffArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.getSpaceManifestDiffArgsForCall = append(fake.getSpaceManifestDiffArgsForCall, FakeCloudControllerClientGetSpaceManifestDiffArgs{arg1, arg2Copy}) stub := fake.GetSpaceManifestDiffStub fakeReturns := fake.getSpaceManifestDiffReturns fake.recordInvocation("GetSpaceManifestDiff", []interface{}{arg1, arg2Copy}) @@ -11246,7 +13047,15 @@ func (fake *FakeCloudControllerClient) GetSpaceManifestDiffArgsForCall(i int) (s fake.getSpaceManifestDiffMutex.RLock() defer fake.getSpaceManifestDiffMutex.RUnlock() argsForCall := fake.getSpaceManifestDiffArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetSpaceManifestDiffArgs() []FakeCloudControllerClientGetSpaceManifestDiffArgs { + fake.getSpaceManifestDiffMutex.RLock() + defer fake.getSpaceManifestDiffMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpaceManifestDiffArgs, len(fake.getSpaceManifestDiffArgsForCall)) + copy(args, fake.getSpaceManifestDiffArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpaceManifestDiffReturns(result1 resources.ManifestDiff, result2 ccv3.Warnings, result3 error) { @@ -11281,9 +13090,7 @@ func (fake *FakeCloudControllerClient) GetSpaceManifestDiffReturnsOnCall(i int, func (fake *FakeCloudControllerClient) GetSpaceQuota(arg1 string) (resources.SpaceQuota, ccv3.Warnings, error) { fake.getSpaceQuotaMutex.Lock() ret, specificReturn := fake.getSpaceQuotaReturnsOnCall[len(fake.getSpaceQuotaArgsForCall)] - fake.getSpaceQuotaArgsForCall = append(fake.getSpaceQuotaArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSpaceQuotaArgsForCall = append(fake.getSpaceQuotaArgsForCall, FakeCloudControllerClientGetSpaceQuotaArgs{arg1}) stub := fake.GetSpaceQuotaStub fakeReturns := fake.getSpaceQuotaReturns fake.recordInvocation("GetSpaceQuota", []interface{}{arg1}) @@ -11313,7 +13120,15 @@ func (fake *FakeCloudControllerClient) GetSpaceQuotaArgsForCall(i int) string { fake.getSpaceQuotaMutex.RLock() defer fake.getSpaceQuotaMutex.RUnlock() argsForCall := fake.getSpaceQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSpaceQuotaArgs() []FakeCloudControllerClientGetSpaceQuotaArgs { + fake.getSpaceQuotaMutex.RLock() + defer fake.getSpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpaceQuotaArgs, len(fake.getSpaceQuotaArgsForCall)) + copy(args, fake.getSpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) { @@ -11346,14 +13161,17 @@ func (fake *FakeCloudControllerClient) GetSpaceQuotaReturnsOnCall(i int, result1 } func (fake *FakeCloudControllerClient) GetSpaceQuotas(arg1 ...ccv3.Query) ([]resources.SpaceQuota, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getSpaceQuotasMutex.Lock() ret, specificReturn := fake.getSpaceQuotasReturnsOnCall[len(fake.getSpaceQuotasArgsForCall)] - fake.getSpaceQuotasArgsForCall = append(fake.getSpaceQuotasArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getSpaceQuotasArgsForCall = append(fake.getSpaceQuotasArgsForCall, FakeCloudControllerClientGetSpaceQuotasArgs{arg1Copy}) stub := fake.GetSpaceQuotasStub fakeReturns := fake.getSpaceQuotasReturns - fake.recordInvocation("GetSpaceQuotas", []interface{}{arg1}) + fake.recordInvocation("GetSpaceQuotas", []interface{}{arg1Copy}) fake.getSpaceQuotasMutex.Unlock() if stub != nil { return stub(arg1...) @@ -11380,7 +13198,15 @@ func (fake *FakeCloudControllerClient) GetSpaceQuotasArgsForCall(i int) []ccv3.Q fake.getSpaceQuotasMutex.RLock() defer fake.getSpaceQuotasMutex.RUnlock() argsForCall := fake.getSpaceQuotasArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSpaceQuotasArgs() []FakeCloudControllerClientGetSpaceQuotasArgs { + fake.getSpaceQuotasMutex.RLock() + defer fake.getSpaceQuotasMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpaceQuotasArgs, len(fake.getSpaceQuotasArgsForCall)) + copy(args, fake.getSpaceQuotasArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpaceQuotasReturns(result1 []resources.SpaceQuota, result2 ccv3.Warnings, result3 error) { @@ -11413,14 +13239,17 @@ func (fake *FakeCloudControllerClient) GetSpaceQuotasReturnsOnCall(i int, result } func (fake *FakeCloudControllerClient) GetSpaces(arg1 ...ccv3.Query) ([]resources.Space, ccv3.IncludedResources, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getSpacesMutex.Lock() ret, specificReturn := fake.getSpacesReturnsOnCall[len(fake.getSpacesArgsForCall)] - fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, FakeCloudControllerClientGetSpacesArgs{arg1Copy}) stub := fake.GetSpacesStub fakeReturns := fake.getSpacesReturns - fake.recordInvocation("GetSpaces", []interface{}{arg1}) + fake.recordInvocation("GetSpaces", []interface{}{arg1Copy}) fake.getSpacesMutex.Unlock() if stub != nil { return stub(arg1...) @@ -11447,7 +13276,15 @@ func (fake *FakeCloudControllerClient) GetSpacesArgsForCall(i int) []ccv3.Query fake.getSpacesMutex.RLock() defer fake.getSpacesMutex.RUnlock() argsForCall := fake.getSpacesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetSpacesArgs() []FakeCloudControllerClientGetSpacesArgs { + fake.getSpacesMutex.RLock() + defer fake.getSpacesMutex.RUnlock() + args := make([]FakeCloudControllerClientGetSpacesArgs, len(fake.getSpacesArgsForCall)) + copy(args, fake.getSpacesArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetSpacesReturns(result1 []resources.Space, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { @@ -11483,14 +13320,17 @@ func (fake *FakeCloudControllerClient) GetSpacesReturnsOnCall(i int, result1 []r } func (fake *FakeCloudControllerClient) GetStacks(arg1 ...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getStacksMutex.Lock() ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)] - fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, FakeCloudControllerClientGetStacksArgs{arg1Copy}) stub := fake.GetStacksStub fakeReturns := fake.getStacksReturns - fake.recordInvocation("GetStacks", []interface{}{arg1}) + fake.recordInvocation("GetStacks", []interface{}{arg1Copy}) fake.getStacksMutex.Unlock() if stub != nil { return stub(arg1...) @@ -11517,7 +13357,15 @@ func (fake *FakeCloudControllerClient) GetStacksArgsForCall(i int) []ccv3.Query fake.getStacksMutex.RLock() defer fake.getStacksMutex.RUnlock() argsForCall := fake.getStacksArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetStacksArgs() []FakeCloudControllerClientGetStacksArgs { + fake.getStacksMutex.RLock() + defer fake.getStacksMutex.RUnlock() + args := make([]FakeCloudControllerClientGetStacksArgs, len(fake.getStacksArgsForCall)) + copy(args, fake.getStacksArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetStacksReturns(result1 []resources.Stack, result2 ccv3.Warnings, result3 error) { @@ -11550,15 +13398,17 @@ func (fake *FakeCloudControllerClient) GetStacksReturnsOnCall(i int, result1 []r } func (fake *FakeCloudControllerClient) GetStagingSecurityGroups(arg1 string, arg2 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) { + var arg2Copy []ccv3.Query + if arg2 != nil { + arg2Copy = make([]ccv3.Query, len(arg2)) + copy(arg2Copy, arg2) + } fake.getStagingSecurityGroupsMutex.Lock() ret, specificReturn := fake.getStagingSecurityGroupsReturnsOnCall[len(fake.getStagingSecurityGroupsArgsForCall)] - fake.getStagingSecurityGroupsArgsForCall = append(fake.getStagingSecurityGroupsArgsForCall, struct { - arg1 string - arg2 []ccv3.Query - }{arg1, arg2}) + fake.getStagingSecurityGroupsArgsForCall = append(fake.getStagingSecurityGroupsArgsForCall, FakeCloudControllerClientGetStagingSecurityGroupsArgs{arg1, arg2Copy}) stub := fake.GetStagingSecurityGroupsStub fakeReturns := fake.getStagingSecurityGroupsReturns - fake.recordInvocation("GetStagingSecurityGroups", []interface{}{arg1, arg2}) + fake.recordInvocation("GetStagingSecurityGroups", []interface{}{arg1, arg2Copy}) fake.getStagingSecurityGroupsMutex.Unlock() if stub != nil { return stub(arg1, arg2...) @@ -11585,7 +13435,15 @@ func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsArgsForCall(i int fake.getStagingSecurityGroupsMutex.RLock() defer fake.getStagingSecurityGroupsMutex.RUnlock() argsForCall := fake.getStagingSecurityGroupsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsArgs() []FakeCloudControllerClientGetStagingSecurityGroupsArgs { + fake.getStagingSecurityGroupsMutex.RLock() + defer fake.getStagingSecurityGroupsMutex.RUnlock() + args := make([]FakeCloudControllerClientGetStagingSecurityGroupsArgs, len(fake.getStagingSecurityGroupsArgsForCall)) + copy(args, fake.getStagingSecurityGroupsArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) { @@ -11620,9 +13478,7 @@ func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsReturnsOnCall(i i func (fake *FakeCloudControllerClient) GetTask(arg1 string) (resources.Task, ccv3.Warnings, error) { fake.getTaskMutex.Lock() ret, specificReturn := fake.getTaskReturnsOnCall[len(fake.getTaskArgsForCall)] - fake.getTaskArgsForCall = append(fake.getTaskArgsForCall, struct { - arg1 string - }{arg1}) + fake.getTaskArgsForCall = append(fake.getTaskArgsForCall, FakeCloudControllerClientGetTaskArgs{arg1}) stub := fake.GetTaskStub fakeReturns := fake.getTaskReturns fake.recordInvocation("GetTask", []interface{}{arg1}) @@ -11652,7 +13508,15 @@ func (fake *FakeCloudControllerClient) GetTaskArgsForCall(i int) string { fake.getTaskMutex.RLock() defer fake.getTaskMutex.RUnlock() argsForCall := fake.getTaskArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetTaskArgs() []FakeCloudControllerClientGetTaskArgs { + fake.getTaskMutex.RLock() + defer fake.getTaskMutex.RUnlock() + args := make([]FakeCloudControllerClientGetTaskArgs, len(fake.getTaskArgsForCall)) + copy(args, fake.getTaskArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetTaskReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) { @@ -11687,9 +13551,7 @@ func (fake *FakeCloudControllerClient) GetTaskReturnsOnCall(i int, result1 resou func (fake *FakeCloudControllerClient) GetUser(arg1 string) (resources.User, ccv3.Warnings, error) { fake.getUserMutex.Lock() ret, specificReturn := fake.getUserReturnsOnCall[len(fake.getUserArgsForCall)] - fake.getUserArgsForCall = append(fake.getUserArgsForCall, struct { - arg1 string - }{arg1}) + fake.getUserArgsForCall = append(fake.getUserArgsForCall, FakeCloudControllerClientGetUserArgs{arg1}) stub := fake.GetUserStub fakeReturns := fake.getUserReturns fake.recordInvocation("GetUser", []interface{}{arg1}) @@ -11719,7 +13581,15 @@ func (fake *FakeCloudControllerClient) GetUserArgsForCall(i int) string { fake.getUserMutex.RLock() defer fake.getUserMutex.RUnlock() argsForCall := fake.getUserArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetUserArgs() []FakeCloudControllerClientGetUserArgs { + fake.getUserMutex.RLock() + defer fake.getUserMutex.RUnlock() + args := make([]FakeCloudControllerClientGetUserArgs, len(fake.getUserArgsForCall)) + copy(args, fake.getUserArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetUserReturns(result1 resources.User, result2 ccv3.Warnings, result3 error) { @@ -11752,14 +13622,17 @@ func (fake *FakeCloudControllerClient) GetUserReturnsOnCall(i int, result1 resou } func (fake *FakeCloudControllerClient) GetUsers(arg1 ...ccv3.Query) ([]resources.User, ccv3.Warnings, error) { + var arg1Copy []ccv3.Query + if arg1 != nil { + arg1Copy = make([]ccv3.Query, len(arg1)) + copy(arg1Copy, arg1) + } fake.getUsersMutex.Lock() ret, specificReturn := fake.getUsersReturnsOnCall[len(fake.getUsersArgsForCall)] - fake.getUsersArgsForCall = append(fake.getUsersArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) + fake.getUsersArgsForCall = append(fake.getUsersArgsForCall, FakeCloudControllerClientGetUsersArgs{arg1Copy}) stub := fake.GetUsersStub fakeReturns := fake.getUsersReturns - fake.recordInvocation("GetUsers", []interface{}{arg1}) + fake.recordInvocation("GetUsers", []interface{}{arg1Copy}) fake.getUsersMutex.Unlock() if stub != nil { return stub(arg1...) @@ -11786,7 +13659,15 @@ func (fake *FakeCloudControllerClient) GetUsersArgsForCall(i int) []ccv3.Query { fake.getUsersMutex.RLock() defer fake.getUsersMutex.RUnlock() argsForCall := fake.getUsersArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) GetUsersArgs() []FakeCloudControllerClientGetUsersArgs { + fake.getUsersMutex.RLock() + defer fake.getUsersMutex.RUnlock() + args := make([]FakeCloudControllerClientGetUsersArgs, len(fake.getUsersArgsForCall)) + copy(args, fake.getUsersArgsForCall) + return args } func (fake *FakeCloudControllerClient) GetUsersReturns(result1 []resources.User, result2 ccv3.Warnings, result3 error) { @@ -11826,12 +13707,7 @@ func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRaw(arg1 string, ar } fake.makeRequestSendReceiveRawMutex.Lock() ret, specificReturn := fake.makeRequestSendReceiveRawReturnsOnCall[len(fake.makeRequestSendReceiveRawArgsForCall)] - fake.makeRequestSendReceiveRawArgsForCall = append(fake.makeRequestSendReceiveRawArgsForCall, struct { - arg1 string - arg2 string - arg3 http.Header - arg4 []byte - }{arg1, arg2, arg3, arg4Copy}) + fake.makeRequestSendReceiveRawArgsForCall = append(fake.makeRequestSendReceiveRawArgsForCall, FakeCloudControllerClientMakeRequestSendReceiveRawArgs{arg1, arg2, arg3, arg4Copy}) stub := fake.MakeRequestSendReceiveRawStub fakeReturns := fake.makeRequestSendReceiveRawReturns fake.recordInvocation("MakeRequestSendReceiveRaw", []interface{}{arg1, arg2, arg3, arg4Copy}) @@ -11861,7 +13737,15 @@ func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawArgsForCall(i in fake.makeRequestSendReceiveRawMutex.RLock() defer fake.makeRequestSendReceiveRawMutex.RUnlock() argsForCall := fake.makeRequestSendReceiveRawArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawArgs() []FakeCloudControllerClientMakeRequestSendReceiveRawArgs { + fake.makeRequestSendReceiveRawMutex.RLock() + defer fake.makeRequestSendReceiveRawMutex.RUnlock() + args := make([]FakeCloudControllerClientMakeRequestSendReceiveRawArgs, len(fake.makeRequestSendReceiveRawArgsForCall)) + copy(args, fake.makeRequestSendReceiveRawArgsForCall) + return args } func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawReturns(result1 []byte, result2 *http.Response, result3 error) { @@ -11896,12 +13780,7 @@ func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawReturnsOnCall(i func (fake *FakeCloudControllerClient) MapRoute(arg1 string, arg2 string, arg3 string, arg4 int) (ccv3.Warnings, error) { fake.mapRouteMutex.Lock() ret, specificReturn := fake.mapRouteReturnsOnCall[len(fake.mapRouteArgsForCall)] - fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, FakeCloudControllerClientMapRouteArgs{arg1, arg2, arg3, arg4}) stub := fake.MapRouteStub fakeReturns := fake.mapRouteReturns fake.recordInvocation("MapRoute", []interface{}{arg1, arg2, arg3, arg4}) @@ -11931,7 +13810,15 @@ func (fake *FakeCloudControllerClient) MapRouteArgsForCall(i int) (string, strin fake.mapRouteMutex.RLock() defer fake.mapRouteMutex.RUnlock() argsForCall := fake.mapRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) MapRouteArgs() []FakeCloudControllerClientMapRouteArgs { + fake.mapRouteMutex.RLock() + defer fake.mapRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientMapRouteArgs, len(fake.mapRouteArgsForCall)) + copy(args, fake.mapRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) MapRouteReturns(result1 ccv3.Warnings, result2 error) { @@ -11963,10 +13850,7 @@ func (fake *FakeCloudControllerClient) MapRouteReturnsOnCall(i int, result1 ccv3 func (fake *FakeCloudControllerClient) MoveRoute(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.moveRouteMutex.Lock() ret, specificReturn := fake.moveRouteReturnsOnCall[len(fake.moveRouteArgsForCall)] - fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, FakeCloudControllerClientMoveRouteArgs{arg1, arg2}) stub := fake.MoveRouteStub fakeReturns := fake.moveRouteReturns fake.recordInvocation("MoveRoute", []interface{}{arg1, arg2}) @@ -11996,7 +13880,15 @@ func (fake *FakeCloudControllerClient) MoveRouteArgsForCall(i int) (string, stri fake.moveRouteMutex.RLock() defer fake.moveRouteMutex.RUnlock() argsForCall := fake.moveRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) MoveRouteArgs() []FakeCloudControllerClientMoveRouteArgs { + fake.moveRouteMutex.RLock() + defer fake.moveRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientMoveRouteArgs, len(fake.moveRouteArgsForCall)) + copy(args, fake.moveRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) MoveRouteReturns(result1 ccv3.Warnings, result2 error) { @@ -12028,9 +13920,7 @@ func (fake *FakeCloudControllerClient) MoveRouteReturnsOnCall(i int, result1 ccv func (fake *FakeCloudControllerClient) PollJob(arg1 ccv3.JobURL) (ccv3.Warnings, error) { fake.pollJobMutex.Lock() ret, specificReturn := fake.pollJobReturnsOnCall[len(fake.pollJobArgsForCall)] - fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, struct { - arg1 ccv3.JobURL - }{arg1}) + fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, FakeCloudControllerClientPollJobArgs{arg1}) stub := fake.PollJobStub fakeReturns := fake.pollJobReturns fake.recordInvocation("PollJob", []interface{}{arg1}) @@ -12060,7 +13950,15 @@ func (fake *FakeCloudControllerClient) PollJobArgsForCall(i int) ccv3.JobURL { fake.pollJobMutex.RLock() defer fake.pollJobMutex.RUnlock() argsForCall := fake.pollJobArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) PollJobArgs() []FakeCloudControllerClientPollJobArgs { + fake.pollJobMutex.RLock() + defer fake.pollJobMutex.RUnlock() + args := make([]FakeCloudControllerClientPollJobArgs, len(fake.pollJobArgsForCall)) + copy(args, fake.pollJobArgsForCall) + return args } func (fake *FakeCloudControllerClient) PollJobReturns(result1 ccv3.Warnings, result2 error) { @@ -12092,10 +13990,7 @@ func (fake *FakeCloudControllerClient) PollJobReturnsOnCall(i int, result1 ccv3. func (fake *FakeCloudControllerClient) PollJobForState(arg1 ccv3.JobURL, arg2 constant.JobState) (ccv3.Warnings, error) { fake.pollJobForStateMutex.Lock() ret, specificReturn := fake.pollJobForStateReturnsOnCall[len(fake.pollJobForStateArgsForCall)] - fake.pollJobForStateArgsForCall = append(fake.pollJobForStateArgsForCall, struct { - arg1 ccv3.JobURL - arg2 constant.JobState - }{arg1, arg2}) + fake.pollJobForStateArgsForCall = append(fake.pollJobForStateArgsForCall, FakeCloudControllerClientPollJobForStateArgs{arg1, arg2}) stub := fake.PollJobForStateStub fakeReturns := fake.pollJobForStateReturns fake.recordInvocation("PollJobForState", []interface{}{arg1, arg2}) @@ -12125,7 +14020,15 @@ func (fake *FakeCloudControllerClient) PollJobForStateArgsForCall(i int) (ccv3.J fake.pollJobForStateMutex.RLock() defer fake.pollJobForStateMutex.RUnlock() argsForCall := fake.pollJobForStateArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) PollJobForStateArgs() []FakeCloudControllerClientPollJobForStateArgs { + fake.pollJobForStateMutex.RLock() + defer fake.pollJobForStateMutex.RUnlock() + args := make([]FakeCloudControllerClientPollJobForStateArgs, len(fake.pollJobForStateArgsForCall)) + copy(args, fake.pollJobForStateArgsForCall) + return args } func (fake *FakeCloudControllerClient) PollJobForStateReturns(result1 ccv3.Warnings, result2 error) { @@ -12157,9 +14060,7 @@ func (fake *FakeCloudControllerClient) PollJobForStateReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) PollJobToEventStream(arg1 ccv3.JobURL) chan ccv3.PollJobEvent { fake.pollJobToEventStreamMutex.Lock() ret, specificReturn := fake.pollJobToEventStreamReturnsOnCall[len(fake.pollJobToEventStreamArgsForCall)] - fake.pollJobToEventStreamArgsForCall = append(fake.pollJobToEventStreamArgsForCall, struct { - arg1 ccv3.JobURL - }{arg1}) + fake.pollJobToEventStreamArgsForCall = append(fake.pollJobToEventStreamArgsForCall, FakeCloudControllerClientPollJobToEventStreamArgs{arg1}) stub := fake.PollJobToEventStreamStub fakeReturns := fake.pollJobToEventStreamReturns fake.recordInvocation("PollJobToEventStream", []interface{}{arg1}) @@ -12189,7 +14090,15 @@ func (fake *FakeCloudControllerClient) PollJobToEventStreamArgsForCall(i int) cc fake.pollJobToEventStreamMutex.RLock() defer fake.pollJobToEventStreamMutex.RUnlock() argsForCall := fake.pollJobToEventStreamArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) PollJobToEventStreamArgs() []FakeCloudControllerClientPollJobToEventStreamArgs { + fake.pollJobToEventStreamMutex.RLock() + defer fake.pollJobToEventStreamMutex.RUnlock() + args := make([]FakeCloudControllerClientPollJobToEventStreamArgs, len(fake.pollJobToEventStreamArgsForCall)) + copy(args, fake.pollJobToEventStreamArgsForCall) + return args } func (fake *FakeCloudControllerClient) PollJobToEventStreamReturns(result1 chan ccv3.PollJobEvent) { @@ -12218,9 +14127,7 @@ func (fake *FakeCloudControllerClient) PollJobToEventStreamReturnsOnCall(i int, func (fake *FakeCloudControllerClient) PurgeServiceOffering(arg1 string) (ccv3.Warnings, error) { fake.purgeServiceOfferingMutex.Lock() ret, specificReturn := fake.purgeServiceOfferingReturnsOnCall[len(fake.purgeServiceOfferingArgsForCall)] - fake.purgeServiceOfferingArgsForCall = append(fake.purgeServiceOfferingArgsForCall, struct { - arg1 string - }{arg1}) + fake.purgeServiceOfferingArgsForCall = append(fake.purgeServiceOfferingArgsForCall, FakeCloudControllerClientPurgeServiceOfferingArgs{arg1}) stub := fake.PurgeServiceOfferingStub fakeReturns := fake.purgeServiceOfferingReturns fake.recordInvocation("PurgeServiceOffering", []interface{}{arg1}) @@ -12250,7 +14157,15 @@ func (fake *FakeCloudControllerClient) PurgeServiceOfferingArgsForCall(i int) st fake.purgeServiceOfferingMutex.RLock() defer fake.purgeServiceOfferingMutex.RUnlock() argsForCall := fake.purgeServiceOfferingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) PurgeServiceOfferingArgs() []FakeCloudControllerClientPurgeServiceOfferingArgs { + fake.purgeServiceOfferingMutex.RLock() + defer fake.purgeServiceOfferingMutex.RUnlock() + args := make([]FakeCloudControllerClientPurgeServiceOfferingArgs, len(fake.purgeServiceOfferingArgsForCall)) + copy(args, fake.purgeServiceOfferingArgsForCall) + return args } func (fake *FakeCloudControllerClient) PurgeServiceOfferingReturns(result1 ccv3.Warnings, result2 error) { @@ -12287,9 +14202,7 @@ func (fake *FakeCloudControllerClient) ResourceMatch(arg1 []ccv3.Resource) ([]cc } fake.resourceMatchMutex.Lock() ret, specificReturn := fake.resourceMatchReturnsOnCall[len(fake.resourceMatchArgsForCall)] - fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, struct { - arg1 []ccv3.Resource - }{arg1Copy}) + fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, FakeCloudControllerClientResourceMatchArgs{arg1Copy}) stub := fake.ResourceMatchStub fakeReturns := fake.resourceMatchReturns fake.recordInvocation("ResourceMatch", []interface{}{arg1Copy}) @@ -12319,7 +14232,15 @@ func (fake *FakeCloudControllerClient) ResourceMatchArgsForCall(i int) []ccv3.Re fake.resourceMatchMutex.RLock() defer fake.resourceMatchMutex.RUnlock() argsForCall := fake.resourceMatchArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) ResourceMatchArgs() []FakeCloudControllerClientResourceMatchArgs { + fake.resourceMatchMutex.RLock() + defer fake.resourceMatchMutex.RUnlock() + args := make([]FakeCloudControllerClientResourceMatchArgs, len(fake.resourceMatchArgsForCall)) + copy(args, fake.resourceMatchArgsForCall) + return args } func (fake *FakeCloudControllerClient) ResourceMatchReturns(result1 []ccv3.Resource, result2 ccv3.Warnings, result3 error) { @@ -12354,8 +14275,7 @@ func (fake *FakeCloudControllerClient) ResourceMatchReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) RootResponse() (ccv3.Root, ccv3.Warnings, error) { fake.rootResponseMutex.Lock() ret, specificReturn := fake.rootResponseReturnsOnCall[len(fake.rootResponseArgsForCall)] - fake.rootResponseArgsForCall = append(fake.rootResponseArgsForCall, struct { - }{}) + fake.rootResponseArgsForCall = append(fake.rootResponseArgsForCall, struct{}{}) stub := fake.RootResponseStub fakeReturns := fake.rootResponseReturns fake.recordInvocation("RootResponse", []interface{}{}) @@ -12413,10 +14333,7 @@ func (fake *FakeCloudControllerClient) RootResponseReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) SetApplicationDroplet(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) { fake.setApplicationDropletMutex.Lock() ret, specificReturn := fake.setApplicationDropletReturnsOnCall[len(fake.setApplicationDropletArgsForCall)] - fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, FakeCloudControllerClientSetApplicationDropletArgs{arg1, arg2}) stub := fake.SetApplicationDropletStub fakeReturns := fake.setApplicationDropletReturns fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2}) @@ -12446,7 +14363,15 @@ func (fake *FakeCloudControllerClient) SetApplicationDropletArgsForCall(i int) ( fake.setApplicationDropletMutex.RLock() defer fake.setApplicationDropletMutex.RUnlock() argsForCall := fake.setApplicationDropletArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) SetApplicationDropletArgs() []FakeCloudControllerClientSetApplicationDropletArgs { + fake.setApplicationDropletMutex.RLock() + defer fake.setApplicationDropletMutex.RUnlock() + args := make([]FakeCloudControllerClientSetApplicationDropletArgs, len(fake.setApplicationDropletArgsForCall)) + copy(args, fake.setApplicationDropletArgsForCall) + return args } func (fake *FakeCloudControllerClient) SetApplicationDropletReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) { @@ -12481,10 +14406,7 @@ func (fake *FakeCloudControllerClient) SetApplicationDropletReturnsOnCall(i int, func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgs(arg1 string, arg2 ccv3.SharedOrgs) (ccv3.Warnings, error) { fake.sharePrivateDomainToOrgsMutex.Lock() ret, specificReturn := fake.sharePrivateDomainToOrgsReturnsOnCall[len(fake.sharePrivateDomainToOrgsArgsForCall)] - fake.sharePrivateDomainToOrgsArgsForCall = append(fake.sharePrivateDomainToOrgsArgsForCall, struct { - arg1 string - arg2 ccv3.SharedOrgs - }{arg1, arg2}) + fake.sharePrivateDomainToOrgsArgsForCall = append(fake.sharePrivateDomainToOrgsArgsForCall, FakeCloudControllerClientSharePrivateDomainToOrgsArgs{arg1, arg2}) stub := fake.SharePrivateDomainToOrgsStub fakeReturns := fake.sharePrivateDomainToOrgsReturns fake.recordInvocation("SharePrivateDomainToOrgs", []interface{}{arg1, arg2}) @@ -12514,7 +14436,15 @@ func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsArgsForCall(i int fake.sharePrivateDomainToOrgsMutex.RLock() defer fake.sharePrivateDomainToOrgsMutex.RUnlock() argsForCall := fake.sharePrivateDomainToOrgsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsArgs() []FakeCloudControllerClientSharePrivateDomainToOrgsArgs { + fake.sharePrivateDomainToOrgsMutex.RLock() + defer fake.sharePrivateDomainToOrgsMutex.RUnlock() + args := make([]FakeCloudControllerClientSharePrivateDomainToOrgsArgs, len(fake.sharePrivateDomainToOrgsArgsForCall)) + copy(args, fake.sharePrivateDomainToOrgsArgsForCall) + return args } func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturns(result1 ccv3.Warnings, result2 error) { @@ -12546,10 +14476,7 @@ func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturnsOnCall(i i func (fake *FakeCloudControllerClient) ShareRoute(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.shareRouteMutex.Lock() ret, specificReturn := fake.shareRouteReturnsOnCall[len(fake.shareRouteArgsForCall)] - fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, FakeCloudControllerClientShareRouteArgs{arg1, arg2}) stub := fake.ShareRouteStub fakeReturns := fake.shareRouteReturns fake.recordInvocation("ShareRoute", []interface{}{arg1, arg2}) @@ -12579,7 +14506,15 @@ func (fake *FakeCloudControllerClient) ShareRouteArgsForCall(i int) (string, str fake.shareRouteMutex.RLock() defer fake.shareRouteMutex.RUnlock() argsForCall := fake.shareRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) ShareRouteArgs() []FakeCloudControllerClientShareRouteArgs { + fake.shareRouteMutex.RLock() + defer fake.shareRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientShareRouteArgs, len(fake.shareRouteArgsForCall)) + copy(args, fake.shareRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) ShareRouteReturns(result1 ccv3.Warnings, result2 error) { @@ -12616,10 +14551,7 @@ func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpaces(arg1 string, } fake.shareServiceInstanceToSpacesMutex.Lock() ret, specificReturn := fake.shareServiceInstanceToSpacesReturnsOnCall[len(fake.shareServiceInstanceToSpacesArgsForCall)] - fake.shareServiceInstanceToSpacesArgsForCall = append(fake.shareServiceInstanceToSpacesArgsForCall, struct { - arg1 string - arg2 []string - }{arg1, arg2Copy}) + fake.shareServiceInstanceToSpacesArgsForCall = append(fake.shareServiceInstanceToSpacesArgsForCall, FakeCloudControllerClientShareServiceInstanceToSpacesArgs{arg1, arg2Copy}) stub := fake.ShareServiceInstanceToSpacesStub fakeReturns := fake.shareServiceInstanceToSpacesReturns fake.recordInvocation("ShareServiceInstanceToSpaces", []interface{}{arg1, arg2Copy}) @@ -12649,7 +14581,15 @@ func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesArgsForCall(i fake.shareServiceInstanceToSpacesMutex.RLock() defer fake.shareServiceInstanceToSpacesMutex.RUnlock() argsForCall := fake.shareServiceInstanceToSpacesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesArgs() []FakeCloudControllerClientShareServiceInstanceToSpacesArgs { + fake.shareServiceInstanceToSpacesMutex.RLock() + defer fake.shareServiceInstanceToSpacesMutex.RUnlock() + args := make([]FakeCloudControllerClientShareServiceInstanceToSpacesArgs, len(fake.shareServiceInstanceToSpacesArgsForCall)) + copy(args, fake.shareServiceInstanceToSpacesArgsForCall) + return args } func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) { @@ -12683,14 +14623,12 @@ func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturnsOnCall func (fake *FakeCloudControllerClient) TargetCF(arg1 ccv3.TargetSettings) { fake.targetCFMutex.Lock() - fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, struct { - arg1 ccv3.TargetSettings - }{arg1}) + fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, FakeCloudControllerClientTargetCFArgs{arg1}) stub := fake.TargetCFStub fake.recordInvocation("TargetCF", []interface{}{arg1}) fake.targetCFMutex.Unlock() if stub != nil { - fake.TargetCFStub(arg1) + stub(arg1) } } @@ -12710,16 +14648,21 @@ func (fake *FakeCloudControllerClient) TargetCFArgsForCall(i int) ccv3.TargetSet fake.targetCFMutex.RLock() defer fake.targetCFMutex.RUnlock() argsForCall := fake.targetCFArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) TargetCFArgs() []FakeCloudControllerClientTargetCFArgs { + fake.targetCFMutex.RLock() + defer fake.targetCFMutex.RUnlock() + args := make([]FakeCloudControllerClientTargetCFArgs, len(fake.targetCFArgsForCall)) + copy(args, fake.targetCFArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpace(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unbindSecurityGroupRunningSpaceMutex.Lock() ret, specificReturn := fake.unbindSecurityGroupRunningSpaceReturnsOnCall[len(fake.unbindSecurityGroupRunningSpaceArgsForCall)] - fake.unbindSecurityGroupRunningSpaceArgsForCall = append(fake.unbindSecurityGroupRunningSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unbindSecurityGroupRunningSpaceArgsForCall = append(fake.unbindSecurityGroupRunningSpaceArgsForCall, FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs{arg1, arg2}) stub := fake.UnbindSecurityGroupRunningSpaceStub fakeReturns := fake.unbindSecurityGroupRunningSpaceReturns fake.recordInvocation("UnbindSecurityGroupRunningSpace", []interface{}{arg1, arg2}) @@ -12749,7 +14692,15 @@ func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceArgsForCal fake.unbindSecurityGroupRunningSpaceMutex.RLock() defer fake.unbindSecurityGroupRunningSpaceMutex.RUnlock() argsForCall := fake.unbindSecurityGroupRunningSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceArgs() []FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs { + fake.unbindSecurityGroupRunningSpaceMutex.RLock() + defer fake.unbindSecurityGroupRunningSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUnbindSecurityGroupRunningSpaceArgs, len(fake.unbindSecurityGroupRunningSpaceArgsForCall)) + copy(args, fake.unbindSecurityGroupRunningSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceReturns(result1 ccv3.Warnings, result2 error) { @@ -12781,10 +14732,7 @@ func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceReturnsOnC func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpace(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unbindSecurityGroupStagingSpaceMutex.Lock() ret, specificReturn := fake.unbindSecurityGroupStagingSpaceReturnsOnCall[len(fake.unbindSecurityGroupStagingSpaceArgsForCall)] - fake.unbindSecurityGroupStagingSpaceArgsForCall = append(fake.unbindSecurityGroupStagingSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unbindSecurityGroupStagingSpaceArgsForCall = append(fake.unbindSecurityGroupStagingSpaceArgsForCall, FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs{arg1, arg2}) stub := fake.UnbindSecurityGroupStagingSpaceStub fakeReturns := fake.unbindSecurityGroupStagingSpaceReturns fake.recordInvocation("UnbindSecurityGroupStagingSpace", []interface{}{arg1, arg2}) @@ -12814,7 +14762,15 @@ func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceArgsForCal fake.unbindSecurityGroupStagingSpaceMutex.RLock() defer fake.unbindSecurityGroupStagingSpaceMutex.RUnlock() argsForCall := fake.unbindSecurityGroupStagingSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceArgs() []FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs { + fake.unbindSecurityGroupStagingSpaceMutex.RLock() + defer fake.unbindSecurityGroupStagingSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUnbindSecurityGroupStagingSpaceArgs, len(fake.unbindSecurityGroupStagingSpaceArgsForCall)) + copy(args, fake.unbindSecurityGroupStagingSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceReturns(result1 ccv3.Warnings, result2 error) { @@ -12846,10 +14802,7 @@ func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceReturnsOnC func (fake *FakeCloudControllerClient) UnmapRoute(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unmapRouteMutex.Lock() ret, specificReturn := fake.unmapRouteReturnsOnCall[len(fake.unmapRouteArgsForCall)] - fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, FakeCloudControllerClientUnmapRouteArgs{arg1, arg2}) stub := fake.UnmapRouteStub fakeReturns := fake.unmapRouteReturns fake.recordInvocation("UnmapRoute", []interface{}{arg1, arg2}) @@ -12879,7 +14832,15 @@ func (fake *FakeCloudControllerClient) UnmapRouteArgsForCall(i int) (string, str fake.unmapRouteMutex.RLock() defer fake.unmapRouteMutex.RUnlock() argsForCall := fake.unmapRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnmapRouteArgs() []FakeCloudControllerClientUnmapRouteArgs { + fake.unmapRouteMutex.RLock() + defer fake.unmapRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientUnmapRouteArgs, len(fake.unmapRouteArgsForCall)) + copy(args, fake.unmapRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnmapRouteReturns(result1 ccv3.Warnings, result2 error) { @@ -12911,10 +14872,7 @@ func (fake *FakeCloudControllerClient) UnmapRouteReturnsOnCall(i int, result1 cc func (fake *FakeCloudControllerClient) UnsetSpaceQuota(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unsetSpaceQuotaMutex.Lock() ret, specificReturn := fake.unsetSpaceQuotaReturnsOnCall[len(fake.unsetSpaceQuotaArgsForCall)] - fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, FakeCloudControllerClientUnsetSpaceQuotaArgs{arg1, arg2}) stub := fake.UnsetSpaceQuotaStub fakeReturns := fake.unsetSpaceQuotaReturns fake.recordInvocation("UnsetSpaceQuota", []interface{}{arg1, arg2}) @@ -12944,7 +14902,15 @@ func (fake *FakeCloudControllerClient) UnsetSpaceQuotaArgsForCall(i int) (string fake.unsetSpaceQuotaMutex.RLock() defer fake.unsetSpaceQuotaMutex.RUnlock() argsForCall := fake.unsetSpaceQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnsetSpaceQuotaArgs() []FakeCloudControllerClientUnsetSpaceQuotaArgs { + fake.unsetSpaceQuotaMutex.RLock() + defer fake.unsetSpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientUnsetSpaceQuotaArgs, len(fake.unsetSpaceQuotaArgsForCall)) + copy(args, fake.unsetSpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnsetSpaceQuotaReturns(result1 ccv3.Warnings, result2 error) { @@ -12976,10 +14942,7 @@ func (fake *FakeCloudControllerClient) UnsetSpaceQuotaReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrg(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unsharePrivateDomainFromOrgMutex.Lock() ret, specificReturn := fake.unsharePrivateDomainFromOrgReturnsOnCall[len(fake.unsharePrivateDomainFromOrgArgsForCall)] - fake.unsharePrivateDomainFromOrgArgsForCall = append(fake.unsharePrivateDomainFromOrgArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unsharePrivateDomainFromOrgArgsForCall = append(fake.unsharePrivateDomainFromOrgArgsForCall, FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs{arg1, arg2}) stub := fake.UnsharePrivateDomainFromOrgStub fakeReturns := fake.unsharePrivateDomainFromOrgReturns fake.recordInvocation("UnsharePrivateDomainFromOrg", []interface{}{arg1, arg2}) @@ -13009,7 +14972,15 @@ func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgArgsForCall(i fake.unsharePrivateDomainFromOrgMutex.RLock() defer fake.unsharePrivateDomainFromOrgMutex.RUnlock() argsForCall := fake.unsharePrivateDomainFromOrgArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgArgs() []FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs { + fake.unsharePrivateDomainFromOrgMutex.RLock() + defer fake.unsharePrivateDomainFromOrgMutex.RUnlock() + args := make([]FakeCloudControllerClientUnsharePrivateDomainFromOrgArgs, len(fake.unsharePrivateDomainFromOrgArgsForCall)) + copy(args, fake.unsharePrivateDomainFromOrgArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturns(result1 ccv3.Warnings, result2 error) { @@ -13041,10 +15012,7 @@ func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturnsOnCall( func (fake *FakeCloudControllerClient) UnshareRoute(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unshareRouteMutex.Lock() ret, specificReturn := fake.unshareRouteReturnsOnCall[len(fake.unshareRouteArgsForCall)] - fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, FakeCloudControllerClientUnshareRouteArgs{arg1, arg2}) stub := fake.UnshareRouteStub fakeReturns := fake.unshareRouteReturns fake.recordInvocation("UnshareRoute", []interface{}{arg1, arg2}) @@ -13074,7 +15042,15 @@ func (fake *FakeCloudControllerClient) UnshareRouteArgsForCall(i int) (string, s fake.unshareRouteMutex.RLock() defer fake.unshareRouteMutex.RUnlock() argsForCall := fake.unshareRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnshareRouteArgs() []FakeCloudControllerClientUnshareRouteArgs { + fake.unshareRouteMutex.RLock() + defer fake.unshareRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientUnshareRouteArgs, len(fake.unshareRouteArgsForCall)) + copy(args, fake.unshareRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnshareRouteReturns(result1 ccv3.Warnings, result2 error) { @@ -13106,10 +15082,7 @@ func (fake *FakeCloudControllerClient) UnshareRouteReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpace(arg1 string, arg2 string) (ccv3.Warnings, error) { fake.unshareServiceInstanceFromSpaceMutex.Lock() ret, specificReturn := fake.unshareServiceInstanceFromSpaceReturnsOnCall[len(fake.unshareServiceInstanceFromSpaceArgsForCall)] - fake.unshareServiceInstanceFromSpaceArgsForCall = append(fake.unshareServiceInstanceFromSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unshareServiceInstanceFromSpaceArgsForCall = append(fake.unshareServiceInstanceFromSpaceArgsForCall, FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs{arg1, arg2}) stub := fake.UnshareServiceInstanceFromSpaceStub fakeReturns := fake.unshareServiceInstanceFromSpaceReturns fake.recordInvocation("UnshareServiceInstanceFromSpace", []interface{}{arg1, arg2}) @@ -13139,7 +15112,15 @@ func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceArgsForCal fake.unshareServiceInstanceFromSpaceMutex.RLock() defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock() argsForCall := fake.unshareServiceInstanceFromSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceArgs() []FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs { + fake.unshareServiceInstanceFromSpaceMutex.RLock() + defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUnshareServiceInstanceFromSpaceArgs, len(fake.unshareServiceInstanceFromSpaceArgsForCall)) + copy(args, fake.unshareServiceInstanceFromSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturns(result1 ccv3.Warnings, result2 error) { @@ -13171,11 +15152,7 @@ func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturnsOnC func (fake *FakeCloudControllerClient) UpdateAppFeature(arg1 string, arg2 bool, arg3 string) (ccv3.Warnings, error) { fake.updateAppFeatureMutex.Lock() ret, specificReturn := fake.updateAppFeatureReturnsOnCall[len(fake.updateAppFeatureArgsForCall)] - fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, struct { - arg1 string - arg2 bool - arg3 string - }{arg1, arg2, arg3}) + fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, FakeCloudControllerClientUpdateAppFeatureArgs{arg1, arg2, arg3}) stub := fake.UpdateAppFeatureStub fakeReturns := fake.updateAppFeatureReturns fake.recordInvocation("UpdateAppFeature", []interface{}{arg1, arg2, arg3}) @@ -13205,7 +15182,15 @@ func (fake *FakeCloudControllerClient) UpdateAppFeatureArgsForCall(i int) (strin fake.updateAppFeatureMutex.RLock() defer fake.updateAppFeatureMutex.RUnlock() argsForCall := fake.updateAppFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) UpdateAppFeatureArgs() []FakeCloudControllerClientUpdateAppFeatureArgs { + fake.updateAppFeatureMutex.RLock() + defer fake.updateAppFeatureMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateAppFeatureArgs, len(fake.updateAppFeatureArgsForCall)) + copy(args, fake.updateAppFeatureArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateAppFeatureReturns(result1 ccv3.Warnings, result2 error) { @@ -13237,9 +15222,7 @@ func (fake *FakeCloudControllerClient) UpdateAppFeatureReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) UpdateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) { fake.updateApplicationMutex.Lock() ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)] - fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct { - arg1 resources.Application - }{arg1}) + fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, FakeCloudControllerClientUpdateApplicationArgs{arg1}) stub := fake.UpdateApplicationStub fakeReturns := fake.updateApplicationReturns fake.recordInvocation("UpdateApplication", []interface{}{arg1}) @@ -13269,7 +15252,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationArgsForCall(i int) resou fake.updateApplicationMutex.RLock() defer fake.updateApplicationMutex.RUnlock() argsForCall := fake.updateApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationArgs() []FakeCloudControllerClientUpdateApplicationArgs { + fake.updateApplicationMutex.RLock() + defer fake.updateApplicationMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationArgs, len(fake.updateApplicationArgsForCall)) + copy(args, fake.updateApplicationArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -13309,10 +15300,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifest(arg1 strin } fake.updateApplicationApplyManifestMutex.Lock() ret, specificReturn := fake.updateApplicationApplyManifestReturnsOnCall[len(fake.updateApplicationApplyManifestArgsForCall)] - fake.updateApplicationApplyManifestArgsForCall = append(fake.updateApplicationApplyManifestArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.updateApplicationApplyManifestArgsForCall = append(fake.updateApplicationApplyManifestArgsForCall, FakeCloudControllerClientUpdateApplicationApplyManifestArgs{arg1, arg2Copy}) stub := fake.UpdateApplicationApplyManifestStub fakeReturns := fake.updateApplicationApplyManifestReturns fake.recordInvocation("UpdateApplicationApplyManifest", []interface{}{arg1, arg2Copy}) @@ -13342,7 +15330,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestArgsForCall fake.updateApplicationApplyManifestMutex.RLock() defer fake.updateApplicationApplyManifestMutex.RUnlock() argsForCall := fake.updateApplicationApplyManifestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestArgs() []FakeCloudControllerClientUpdateApplicationApplyManifestArgs { + fake.updateApplicationApplyManifestMutex.RLock() + defer fake.updateApplicationApplyManifestMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationApplyManifestArgs, len(fake.updateApplicationApplyManifestArgsForCall)) + copy(args, fake.updateApplicationApplyManifestArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -13377,10 +15373,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturnsOnCa func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariables(arg1 string, arg2 resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) { fake.updateApplicationEnvironmentVariablesMutex.Lock() ret, specificReturn := fake.updateApplicationEnvironmentVariablesReturnsOnCall[len(fake.updateApplicationEnvironmentVariablesArgsForCall)] - fake.updateApplicationEnvironmentVariablesArgsForCall = append(fake.updateApplicationEnvironmentVariablesArgsForCall, struct { - arg1 string - arg2 resources.EnvironmentVariables - }{arg1, arg2}) + fake.updateApplicationEnvironmentVariablesArgsForCall = append(fake.updateApplicationEnvironmentVariablesArgsForCall, FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs{arg1, arg2}) stub := fake.UpdateApplicationEnvironmentVariablesStub fakeReturns := fake.updateApplicationEnvironmentVariablesReturns fake.recordInvocation("UpdateApplicationEnvironmentVariables", []interface{}{arg1, arg2}) @@ -13410,7 +15403,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesArgs fake.updateApplicationEnvironmentVariablesMutex.RLock() defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock() argsForCall := fake.updateApplicationEnvironmentVariablesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesArgs() []FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs { + fake.updateApplicationEnvironmentVariablesMutex.RLock() + defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationEnvironmentVariablesArgs, len(fake.updateApplicationEnvironmentVariablesArgsForCall)) + copy(args, fake.updateApplicationEnvironmentVariablesArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) { @@ -13445,10 +15446,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesRetu func (fake *FakeCloudControllerClient) UpdateApplicationName(arg1 string, arg2 string) (resources.Application, ccv3.Warnings, error) { fake.updateApplicationNameMutex.Lock() ret, specificReturn := fake.updateApplicationNameReturnsOnCall[len(fake.updateApplicationNameArgsForCall)] - fake.updateApplicationNameArgsForCall = append(fake.updateApplicationNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.updateApplicationNameArgsForCall = append(fake.updateApplicationNameArgsForCall, FakeCloudControllerClientUpdateApplicationNameArgs{arg1, arg2}) stub := fake.UpdateApplicationNameStub fakeReturns := fake.updateApplicationNameReturns fake.recordInvocation("UpdateApplicationName", []interface{}{arg1, arg2}) @@ -13478,7 +15476,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationNameArgsForCall(i int) ( fake.updateApplicationNameMutex.RLock() defer fake.updateApplicationNameMutex.RUnlock() argsForCall := fake.updateApplicationNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationNameArgs() []FakeCloudControllerClientUpdateApplicationNameArgs { + fake.updateApplicationNameMutex.RLock() + defer fake.updateApplicationNameMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationNameArgs, len(fake.updateApplicationNameArgsForCall)) + copy(args, fake.updateApplicationNameArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationNameReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -13513,9 +15519,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationNameReturnsOnCall(i int, func (fake *FakeCloudControllerClient) UpdateApplicationRestart(arg1 string) (resources.Application, ccv3.Warnings, error) { fake.updateApplicationRestartMutex.Lock() ret, specificReturn := fake.updateApplicationRestartReturnsOnCall[len(fake.updateApplicationRestartArgsForCall)] - fake.updateApplicationRestartArgsForCall = append(fake.updateApplicationRestartArgsForCall, struct { - arg1 string - }{arg1}) + fake.updateApplicationRestartArgsForCall = append(fake.updateApplicationRestartArgsForCall, FakeCloudControllerClientUpdateApplicationRestartArgs{arg1}) stub := fake.UpdateApplicationRestartStub fakeReturns := fake.updateApplicationRestartReturns fake.recordInvocation("UpdateApplicationRestart", []interface{}{arg1}) @@ -13545,7 +15549,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationRestartArgsForCall(i int fake.updateApplicationRestartMutex.RLock() defer fake.updateApplicationRestartMutex.RUnlock() argsForCall := fake.updateApplicationRestartArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationRestartArgs() []FakeCloudControllerClientUpdateApplicationRestartArgs { + fake.updateApplicationRestartMutex.RLock() + defer fake.updateApplicationRestartMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationRestartArgs, len(fake.updateApplicationRestartArgsForCall)) + copy(args, fake.updateApplicationRestartArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -13577,12 +15589,83 @@ func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturnsOnCall(i i }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccount(arg1 string, arg2 resources.Relationship) (ccv3.JobURL, ccv3.Warnings, error) { + fake.updateApplicationServiceAccountMutex.Lock() + ret, specificReturn := fake.updateApplicationServiceAccountReturnsOnCall[len(fake.updateApplicationServiceAccountArgsForCall)] + fake.updateApplicationServiceAccountArgsForCall = append(fake.updateApplicationServiceAccountArgsForCall, FakeCloudControllerClientUpdateApplicationServiceAccountArgs{arg1, arg2}) + stub := fake.UpdateApplicationServiceAccountStub + fakeReturns := fake.updateApplicationServiceAccountReturns + fake.recordInvocation("UpdateApplicationServiceAccount", []interface{}{arg1, arg2}) + fake.updateApplicationServiceAccountMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountCallCount() int { + fake.updateApplicationServiceAccountMutex.RLock() + defer fake.updateApplicationServiceAccountMutex.RUnlock() + return len(fake.updateApplicationServiceAccountArgsForCall) +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountCalls(stub func(string, resources.Relationship) (ccv3.JobURL, ccv3.Warnings, error)) { + fake.updateApplicationServiceAccountMutex.Lock() + defer fake.updateApplicationServiceAccountMutex.Unlock() + fake.UpdateApplicationServiceAccountStub = stub +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountArgsForCall(i int) (string, resources.Relationship) { + fake.updateApplicationServiceAccountMutex.RLock() + defer fake.updateApplicationServiceAccountMutex.RUnlock() + argsForCall := fake.updateApplicationServiceAccountArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountArgs() []FakeCloudControllerClientUpdateApplicationServiceAccountArgs { + fake.updateApplicationServiceAccountMutex.RLock() + defer fake.updateApplicationServiceAccountMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationServiceAccountArgs, len(fake.updateApplicationServiceAccountArgsForCall)) + copy(args, fake.updateApplicationServiceAccountArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.updateApplicationServiceAccountMutex.Lock() + defer fake.updateApplicationServiceAccountMutex.Unlock() + fake.UpdateApplicationServiceAccountStub = nil + fake.updateApplicationServiceAccountReturns = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) UpdateApplicationServiceAccountReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.updateApplicationServiceAccountMutex.Lock() + defer fake.updateApplicationServiceAccountMutex.Unlock() + fake.UpdateApplicationServiceAccountStub = nil + if fake.updateApplicationServiceAccountReturnsOnCall == nil { + fake.updateApplicationServiceAccountReturnsOnCall = make(map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }) + } + fake.updateApplicationServiceAccountReturnsOnCall[i] = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) UpdateApplicationStart(arg1 string) (resources.Application, ccv3.Warnings, error) { fake.updateApplicationStartMutex.Lock() ret, specificReturn := fake.updateApplicationStartReturnsOnCall[len(fake.updateApplicationStartArgsForCall)] - fake.updateApplicationStartArgsForCall = append(fake.updateApplicationStartArgsForCall, struct { - arg1 string - }{arg1}) + fake.updateApplicationStartArgsForCall = append(fake.updateApplicationStartArgsForCall, FakeCloudControllerClientUpdateApplicationStartArgs{arg1}) stub := fake.UpdateApplicationStartStub fakeReturns := fake.updateApplicationStartReturns fake.recordInvocation("UpdateApplicationStart", []interface{}{arg1}) @@ -13612,7 +15695,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationStartArgsForCall(i int) fake.updateApplicationStartMutex.RLock() defer fake.updateApplicationStartMutex.RUnlock() argsForCall := fake.updateApplicationStartArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationStartArgs() []FakeCloudControllerClientUpdateApplicationStartArgs { + fake.updateApplicationStartMutex.RLock() + defer fake.updateApplicationStartMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationStartArgs, len(fake.updateApplicationStartArgsForCall)) + copy(args, fake.updateApplicationStartArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationStartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -13647,9 +15738,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationStartReturnsOnCall(i int func (fake *FakeCloudControllerClient) UpdateApplicationStop(arg1 string) (resources.Application, ccv3.Warnings, error) { fake.updateApplicationStopMutex.Lock() ret, specificReturn := fake.updateApplicationStopReturnsOnCall[len(fake.updateApplicationStopArgsForCall)] - fake.updateApplicationStopArgsForCall = append(fake.updateApplicationStopArgsForCall, struct { - arg1 string - }{arg1}) + fake.updateApplicationStopArgsForCall = append(fake.updateApplicationStopArgsForCall, FakeCloudControllerClientUpdateApplicationStopArgs{arg1}) stub := fake.UpdateApplicationStopStub fakeReturns := fake.updateApplicationStopReturns fake.recordInvocation("UpdateApplicationStop", []interface{}{arg1}) @@ -13679,7 +15768,15 @@ func (fake *FakeCloudControllerClient) UpdateApplicationStopArgsForCall(i int) s fake.updateApplicationStopMutex.RLock() defer fake.updateApplicationStopMutex.RUnlock() argsForCall := fake.updateApplicationStopArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateApplicationStopArgs() []FakeCloudControllerClientUpdateApplicationStopArgs { + fake.updateApplicationStopMutex.RLock() + defer fake.updateApplicationStopMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateApplicationStopArgs, len(fake.updateApplicationStopArgsForCall)) + copy(args, fake.updateApplicationStopArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateApplicationStopReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) { @@ -13714,9 +15811,7 @@ func (fake *FakeCloudControllerClient) UpdateApplicationStopReturnsOnCall(i int, func (fake *FakeCloudControllerClient) UpdateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) { fake.updateBuildpackMutex.Lock() ret, specificReturn := fake.updateBuildpackReturnsOnCall[len(fake.updateBuildpackArgsForCall)] - fake.updateBuildpackArgsForCall = append(fake.updateBuildpackArgsForCall, struct { - arg1 resources.Buildpack - }{arg1}) + fake.updateBuildpackArgsForCall = append(fake.updateBuildpackArgsForCall, FakeCloudControllerClientUpdateBuildpackArgs{arg1}) stub := fake.UpdateBuildpackStub fakeReturns := fake.updateBuildpackReturns fake.recordInvocation("UpdateBuildpack", []interface{}{arg1}) @@ -13746,7 +15841,15 @@ func (fake *FakeCloudControllerClient) UpdateBuildpackArgsForCall(i int) resourc fake.updateBuildpackMutex.RLock() defer fake.updateBuildpackMutex.RUnlock() argsForCall := fake.updateBuildpackArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateBuildpackArgs() []FakeCloudControllerClientUpdateBuildpackArgs { + fake.updateBuildpackMutex.RLock() + defer fake.updateBuildpackMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateBuildpackArgs, len(fake.updateBuildpackArgsForCall)) + copy(args, fake.updateBuildpackArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateBuildpackReturns(result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) { @@ -13781,11 +15884,7 @@ func (fake *FakeCloudControllerClient) UpdateBuildpackReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) UpdateDestination(arg1 string, arg2 string, arg3 string) (ccv3.Warnings, error) { fake.updateDestinationMutex.Lock() ret, specificReturn := fake.updateDestinationReturnsOnCall[len(fake.updateDestinationArgsForCall)] - fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, FakeCloudControllerClientUpdateDestinationArgs{arg1, arg2, arg3}) stub := fake.UpdateDestinationStub fakeReturns := fake.updateDestinationReturns fake.recordInvocation("UpdateDestination", []interface{}{arg1, arg2, arg3}) @@ -13815,7 +15914,15 @@ func (fake *FakeCloudControllerClient) UpdateDestinationArgsForCall(i int) (stri fake.updateDestinationMutex.RLock() defer fake.updateDestinationMutex.RUnlock() argsForCall := fake.updateDestinationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) UpdateDestinationArgs() []FakeCloudControllerClientUpdateDestinationArgs { + fake.updateDestinationMutex.RLock() + defer fake.updateDestinationMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateDestinationArgs, len(fake.updateDestinationArgsForCall)) + copy(args, fake.updateDestinationArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateDestinationReturns(result1 ccv3.Warnings, result2 error) { @@ -13847,10 +15954,7 @@ func (fake *FakeCloudControllerClient) UpdateDestinationReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroup(arg1 constant.EnvironmentVariableGroupName, arg2 resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) { fake.updateEnvironmentVariableGroupMutex.Lock() ret, specificReturn := fake.updateEnvironmentVariableGroupReturnsOnCall[len(fake.updateEnvironmentVariableGroupArgsForCall)] - fake.updateEnvironmentVariableGroupArgsForCall = append(fake.updateEnvironmentVariableGroupArgsForCall, struct { - arg1 constant.EnvironmentVariableGroupName - arg2 resources.EnvironmentVariables - }{arg1, arg2}) + fake.updateEnvironmentVariableGroupArgsForCall = append(fake.updateEnvironmentVariableGroupArgsForCall, FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs{arg1, arg2}) stub := fake.UpdateEnvironmentVariableGroupStub fakeReturns := fake.updateEnvironmentVariableGroupReturns fake.recordInvocation("UpdateEnvironmentVariableGroup", []interface{}{arg1, arg2}) @@ -13880,7 +15984,15 @@ func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupArgsForCall fake.updateEnvironmentVariableGroupMutex.RLock() defer fake.updateEnvironmentVariableGroupMutex.RUnlock() argsForCall := fake.updateEnvironmentVariableGroupArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupArgs() []FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs { + fake.updateEnvironmentVariableGroupMutex.RLock() + defer fake.updateEnvironmentVariableGroupMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateEnvironmentVariableGroupArgs, len(fake.updateEnvironmentVariableGroupArgsForCall)) + copy(args, fake.updateEnvironmentVariableGroupArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) { @@ -13915,9 +16027,7 @@ func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupReturnsOnCa func (fake *FakeCloudControllerClient) UpdateFeatureFlag(arg1 resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error) { fake.updateFeatureFlagMutex.Lock() ret, specificReturn := fake.updateFeatureFlagReturnsOnCall[len(fake.updateFeatureFlagArgsForCall)] - fake.updateFeatureFlagArgsForCall = append(fake.updateFeatureFlagArgsForCall, struct { - arg1 resources.FeatureFlag - }{arg1}) + fake.updateFeatureFlagArgsForCall = append(fake.updateFeatureFlagArgsForCall, FakeCloudControllerClientUpdateFeatureFlagArgs{arg1}) stub := fake.UpdateFeatureFlagStub fakeReturns := fake.updateFeatureFlagReturns fake.recordInvocation("UpdateFeatureFlag", []interface{}{arg1}) @@ -13947,7 +16057,15 @@ func (fake *FakeCloudControllerClient) UpdateFeatureFlagArgsForCall(i int) resou fake.updateFeatureFlagMutex.RLock() defer fake.updateFeatureFlagMutex.RUnlock() argsForCall := fake.updateFeatureFlagArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateFeatureFlagArgs() []FakeCloudControllerClientUpdateFeatureFlagArgs { + fake.updateFeatureFlagMutex.RLock() + defer fake.updateFeatureFlagMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateFeatureFlagArgs, len(fake.updateFeatureFlagArgsForCall)) + copy(args, fake.updateFeatureFlagArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) { @@ -13982,9 +16100,7 @@ func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) UpdateOrganization(arg1 resources.Organization) (resources.Organization, ccv3.Warnings, error) { fake.updateOrganizationMutex.Lock() ret, specificReturn := fake.updateOrganizationReturnsOnCall[len(fake.updateOrganizationArgsForCall)] - fake.updateOrganizationArgsForCall = append(fake.updateOrganizationArgsForCall, struct { - arg1 resources.Organization - }{arg1}) + fake.updateOrganizationArgsForCall = append(fake.updateOrganizationArgsForCall, FakeCloudControllerClientUpdateOrganizationArgs{arg1}) stub := fake.UpdateOrganizationStub fakeReturns := fake.updateOrganizationReturns fake.recordInvocation("UpdateOrganization", []interface{}{arg1}) @@ -14014,7 +16130,15 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationArgsForCall(i int) reso fake.updateOrganizationMutex.RLock() defer fake.updateOrganizationMutex.RUnlock() argsForCall := fake.updateOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateOrganizationArgs() []FakeCloudControllerClientUpdateOrganizationArgs { + fake.updateOrganizationMutex.RLock() + defer fake.updateOrganizationMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateOrganizationArgs, len(fake.updateOrganizationArgsForCall)) + copy(args, fake.updateOrganizationArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) { @@ -14049,10 +16173,7 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) { fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock() ret, specificReturn := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall[len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)] - fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall = append(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall = append(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall, FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs{arg1, arg2}) stub := fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub fakeReturns := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns fake.recordInvocation("UpdateOrganizationDefaultIsolationSegmentRelationship", []interface{}{arg1, arg2}) @@ -14082,7 +16203,15 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegment fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock() defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock() argsForCall := fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipArgs() []FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs { + fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock() + defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateOrganizationDefaultIsolationSegmentRelationshipArgs, len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)) + copy(args, fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) { @@ -14117,9 +16246,7 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegment func (fake *FakeCloudControllerClient) UpdateOrganizationQuota(arg1 resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) { fake.updateOrganizationQuotaMutex.Lock() ret, specificReturn := fake.updateOrganizationQuotaReturnsOnCall[len(fake.updateOrganizationQuotaArgsForCall)] - fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, struct { - arg1 resources.OrganizationQuota - }{arg1}) + fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, FakeCloudControllerClientUpdateOrganizationQuotaArgs{arg1}) stub := fake.UpdateOrganizationQuotaStub fakeReturns := fake.updateOrganizationQuotaReturns fake.recordInvocation("UpdateOrganizationQuota", []interface{}{arg1}) @@ -14149,7 +16276,15 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaArgsForCall(i int) fake.updateOrganizationQuotaMutex.RLock() defer fake.updateOrganizationQuotaMutex.RUnlock() argsForCall := fake.updateOrganizationQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaArgs() []FakeCloudControllerClientUpdateOrganizationQuotaArgs { + fake.updateOrganizationQuotaMutex.RLock() + defer fake.updateOrganizationQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateOrganizationQuotaArgs, len(fake.updateOrganizationQuotaArgsForCall)) + copy(args, fake.updateOrganizationQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) { @@ -14184,9 +16319,7 @@ func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaReturnsOnCall(i in func (fake *FakeCloudControllerClient) UpdateProcess(arg1 resources.Process) (resources.Process, ccv3.Warnings, error) { fake.updateProcessMutex.Lock() ret, specificReturn := fake.updateProcessReturnsOnCall[len(fake.updateProcessArgsForCall)] - fake.updateProcessArgsForCall = append(fake.updateProcessArgsForCall, struct { - arg1 resources.Process - }{arg1}) + fake.updateProcessArgsForCall = append(fake.updateProcessArgsForCall, FakeCloudControllerClientUpdateProcessArgs{arg1}) stub := fake.UpdateProcessStub fakeReturns := fake.updateProcessReturns fake.recordInvocation("UpdateProcess", []interface{}{arg1}) @@ -14216,7 +16349,15 @@ func (fake *FakeCloudControllerClient) UpdateProcessArgsForCall(i int) resources fake.updateProcessMutex.RLock() defer fake.updateProcessMutex.RUnlock() argsForCall := fake.updateProcessArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateProcessArgs() []FakeCloudControllerClientUpdateProcessArgs { + fake.updateProcessMutex.RLock() + defer fake.updateProcessMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateProcessArgs, len(fake.updateProcessArgsForCall)) + copy(args, fake.updateProcessArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateProcessReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) { @@ -14251,11 +16392,7 @@ func (fake *FakeCloudControllerClient) UpdateProcessReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) UpdateResourceMetadata(arg1 string, arg2 string, arg3 resources.Metadata) (ccv3.JobURL, ccv3.Warnings, error) { fake.updateResourceMetadataMutex.Lock() ret, specificReturn := fake.updateResourceMetadataReturnsOnCall[len(fake.updateResourceMetadataArgsForCall)] - fake.updateResourceMetadataArgsForCall = append(fake.updateResourceMetadataArgsForCall, struct { - arg1 string - arg2 string - arg3 resources.Metadata - }{arg1, arg2, arg3}) + fake.updateResourceMetadataArgsForCall = append(fake.updateResourceMetadataArgsForCall, FakeCloudControllerClientUpdateResourceMetadataArgs{arg1, arg2, arg3}) stub := fake.UpdateResourceMetadataStub fakeReturns := fake.updateResourceMetadataReturns fake.recordInvocation("UpdateResourceMetadata", []interface{}{arg1, arg2, arg3}) @@ -14285,7 +16422,15 @@ func (fake *FakeCloudControllerClient) UpdateResourceMetadataArgsForCall(i int) fake.updateResourceMetadataMutex.RLock() defer fake.updateResourceMetadataMutex.RUnlock() argsForCall := fake.updateResourceMetadataArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) UpdateResourceMetadataArgs() []FakeCloudControllerClientUpdateResourceMetadataArgs { + fake.updateResourceMetadataMutex.RLock() + defer fake.updateResourceMetadataMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateResourceMetadataArgs, len(fake.updateResourceMetadataArgsForCall)) + copy(args, fake.updateResourceMetadataArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateResourceMetadataReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -14320,10 +16465,7 @@ func (fake *FakeCloudControllerClient) UpdateResourceMetadataReturnsOnCall(i int func (fake *FakeCloudControllerClient) UpdateRoute(arg1 string, arg2 map[string]*string) (resources.Route, ccv3.Warnings, error) { fake.updateRouteMutex.Lock() ret, specificReturn := fake.updateRouteReturnsOnCall[len(fake.updateRouteArgsForCall)] - fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, struct { - arg1 string - arg2 map[string]*string - }{arg1, arg2}) + fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, FakeCloudControllerClientUpdateRouteArgs{arg1, arg2}) stub := fake.UpdateRouteStub fakeReturns := fake.updateRouteReturns fake.recordInvocation("UpdateRoute", []interface{}{arg1, arg2}) @@ -14353,7 +16495,15 @@ func (fake *FakeCloudControllerClient) UpdateRouteArgsForCall(i int) (string, ma fake.updateRouteMutex.RLock() defer fake.updateRouteMutex.RUnlock() argsForCall := fake.updateRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateRouteArgs() []FakeCloudControllerClientUpdateRouteArgs { + fake.updateRouteMutex.RLock() + defer fake.updateRouteMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateRouteArgs, len(fake.updateRouteArgsForCall)) + copy(args, fake.updateRouteArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateRouteReturns(result1 resources.Route, result2 ccv3.Warnings, result3 error) { @@ -14388,9 +16538,7 @@ func (fake *FakeCloudControllerClient) UpdateRouteReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) UpdateSecurityGroup(arg1 resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) { fake.updateSecurityGroupMutex.Lock() ret, specificReturn := fake.updateSecurityGroupReturnsOnCall[len(fake.updateSecurityGroupArgsForCall)] - fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, struct { - arg1 resources.SecurityGroup - }{arg1}) + fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, FakeCloudControllerClientUpdateSecurityGroupArgs{arg1}) stub := fake.UpdateSecurityGroupStub fakeReturns := fake.updateSecurityGroupReturns fake.recordInvocation("UpdateSecurityGroup", []interface{}{arg1}) @@ -14420,7 +16568,15 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupArgsForCall(i int) res fake.updateSecurityGroupMutex.RLock() defer fake.updateSecurityGroupMutex.RUnlock() argsForCall := fake.updateSecurityGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateSecurityGroupArgs() []FakeCloudControllerClientUpdateSecurityGroupArgs { + fake.updateSecurityGroupMutex.RLock() + defer fake.updateSecurityGroupMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSecurityGroupArgs, len(fake.updateSecurityGroupArgsForCall)) + copy(args, fake.updateSecurityGroupArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSecurityGroupReturns(result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) { @@ -14460,10 +16616,7 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpace(arg1 stri } fake.updateSecurityGroupRunningSpaceMutex.Lock() ret, specificReturn := fake.updateSecurityGroupRunningSpaceReturnsOnCall[len(fake.updateSecurityGroupRunningSpaceArgsForCall)] - fake.updateSecurityGroupRunningSpaceArgsForCall = append(fake.updateSecurityGroupRunningSpaceArgsForCall, struct { - arg1 string - arg2 []string - }{arg1, arg2Copy}) + fake.updateSecurityGroupRunningSpaceArgsForCall = append(fake.updateSecurityGroupRunningSpaceArgsForCall, FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs{arg1, arg2Copy}) stub := fake.UpdateSecurityGroupRunningSpaceStub fakeReturns := fake.updateSecurityGroupRunningSpaceReturns fake.recordInvocation("UpdateSecurityGroupRunningSpace", []interface{}{arg1, arg2Copy}) @@ -14493,7 +16646,15 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceArgsForCal fake.updateSecurityGroupRunningSpaceMutex.RLock() defer fake.updateSecurityGroupRunningSpaceMutex.RUnlock() argsForCall := fake.updateSecurityGroupRunningSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceArgs() []FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs { + fake.updateSecurityGroupRunningSpaceMutex.RLock() + defer fake.updateSecurityGroupRunningSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSecurityGroupRunningSpaceArgs, len(fake.updateSecurityGroupRunningSpaceArgsForCall)) + copy(args, fake.updateSecurityGroupRunningSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceReturns(result1 ccv3.Warnings, result2 error) { @@ -14530,10 +16691,7 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpace(arg1 stri } fake.updateSecurityGroupStagingSpaceMutex.Lock() ret, specificReturn := fake.updateSecurityGroupStagingSpaceReturnsOnCall[len(fake.updateSecurityGroupStagingSpaceArgsForCall)] - fake.updateSecurityGroupStagingSpaceArgsForCall = append(fake.updateSecurityGroupStagingSpaceArgsForCall, struct { - arg1 string - arg2 []string - }{arg1, arg2Copy}) + fake.updateSecurityGroupStagingSpaceArgsForCall = append(fake.updateSecurityGroupStagingSpaceArgsForCall, FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs{arg1, arg2Copy}) stub := fake.UpdateSecurityGroupStagingSpaceStub fakeReturns := fake.updateSecurityGroupStagingSpaceReturns fake.recordInvocation("UpdateSecurityGroupStagingSpace", []interface{}{arg1, arg2Copy}) @@ -14563,7 +16721,15 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceArgsForCal fake.updateSecurityGroupStagingSpaceMutex.RLock() defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock() argsForCall := fake.updateSecurityGroupStagingSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceArgs() []FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs { + fake.updateSecurityGroupStagingSpaceMutex.RLock() + defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSecurityGroupStagingSpaceArgs, len(fake.updateSecurityGroupStagingSpaceArgsForCall)) + copy(args, fake.updateSecurityGroupStagingSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturns(result1 ccv3.Warnings, result2 error) { @@ -14592,13 +16758,83 @@ func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturnsOnC }{result1, result2} } +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabled(arg1 string, arg2 bool) (ccv3.JobURL, ccv3.Warnings, error) { + fake.updateServiceAccountEnabledMutex.Lock() + ret, specificReturn := fake.updateServiceAccountEnabledReturnsOnCall[len(fake.updateServiceAccountEnabledArgsForCall)] + fake.updateServiceAccountEnabledArgsForCall = append(fake.updateServiceAccountEnabledArgsForCall, FakeCloudControllerClientUpdateServiceAccountEnabledArgs{arg1, arg2}) + stub := fake.UpdateServiceAccountEnabledStub + fakeReturns := fake.updateServiceAccountEnabledReturns + fake.recordInvocation("UpdateServiceAccountEnabled", []interface{}{arg1, arg2}) + fake.updateServiceAccountEnabledMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledCallCount() int { + fake.updateServiceAccountEnabledMutex.RLock() + defer fake.updateServiceAccountEnabledMutex.RUnlock() + return len(fake.updateServiceAccountEnabledArgsForCall) +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledCalls(stub func(string, bool) (ccv3.JobURL, ccv3.Warnings, error)) { + fake.updateServiceAccountEnabledMutex.Lock() + defer fake.updateServiceAccountEnabledMutex.Unlock() + fake.UpdateServiceAccountEnabledStub = stub +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledArgsForCall(i int) (string, bool) { + fake.updateServiceAccountEnabledMutex.RLock() + defer fake.updateServiceAccountEnabledMutex.RUnlock() + argsForCall := fake.updateServiceAccountEnabledArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledArgs() []FakeCloudControllerClientUpdateServiceAccountEnabledArgs { + fake.updateServiceAccountEnabledMutex.RLock() + defer fake.updateServiceAccountEnabledMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateServiceAccountEnabledArgs, len(fake.updateServiceAccountEnabledArgsForCall)) + copy(args, fake.updateServiceAccountEnabledArgsForCall) + return args +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.updateServiceAccountEnabledMutex.Lock() + defer fake.updateServiceAccountEnabledMutex.Unlock() + fake.UpdateServiceAccountEnabledStub = nil + fake.updateServiceAccountEnabledReturns = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) UpdateServiceAccountEnabledReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.updateServiceAccountEnabledMutex.Lock() + defer fake.updateServiceAccountEnabledMutex.Unlock() + fake.UpdateServiceAccountEnabledStub = nil + if fake.updateServiceAccountEnabledReturnsOnCall == nil { + fake.updateServiceAccountEnabledReturnsOnCall = make(map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }) + } + fake.updateServiceAccountEnabledReturnsOnCall[i] = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) UpdateServiceBroker(arg1 string, arg2 resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) { fake.updateServiceBrokerMutex.Lock() ret, specificReturn := fake.updateServiceBrokerReturnsOnCall[len(fake.updateServiceBrokerArgsForCall)] - fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, struct { - arg1 string - arg2 resources.ServiceBroker - }{arg1, arg2}) + fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, FakeCloudControllerClientUpdateServiceBrokerArgs{arg1, arg2}) stub := fake.UpdateServiceBrokerStub fakeReturns := fake.updateServiceBrokerReturns fake.recordInvocation("UpdateServiceBroker", []interface{}{arg1, arg2}) @@ -14628,7 +16864,15 @@ func (fake *FakeCloudControllerClient) UpdateServiceBrokerArgsForCall(i int) (st fake.updateServiceBrokerMutex.RLock() defer fake.updateServiceBrokerMutex.RUnlock() argsForCall := fake.updateServiceBrokerArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateServiceBrokerArgs() []FakeCloudControllerClientUpdateServiceBrokerArgs { + fake.updateServiceBrokerMutex.RLock() + defer fake.updateServiceBrokerMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateServiceBrokerArgs, len(fake.updateServiceBrokerArgsForCall)) + copy(args, fake.updateServiceBrokerArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -14663,10 +16907,7 @@ func (fake *FakeCloudControllerClient) UpdateServiceBrokerReturnsOnCall(i int, r func (fake *FakeCloudControllerClient) UpdateServiceInstance(arg1 string, arg2 resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) { fake.updateServiceInstanceMutex.Lock() ret, specificReturn := fake.updateServiceInstanceReturnsOnCall[len(fake.updateServiceInstanceArgsForCall)] - fake.updateServiceInstanceArgsForCall = append(fake.updateServiceInstanceArgsForCall, struct { - arg1 string - arg2 resources.ServiceInstance - }{arg1, arg2}) + fake.updateServiceInstanceArgsForCall = append(fake.updateServiceInstanceArgsForCall, FakeCloudControllerClientUpdateServiceInstanceArgs{arg1, arg2}) stub := fake.UpdateServiceInstanceStub fakeReturns := fake.updateServiceInstanceReturns fake.recordInvocation("UpdateServiceInstance", []interface{}{arg1, arg2}) @@ -14696,7 +16937,15 @@ func (fake *FakeCloudControllerClient) UpdateServiceInstanceArgsForCall(i int) ( fake.updateServiceInstanceMutex.RLock() defer fake.updateServiceInstanceMutex.RUnlock() argsForCall := fake.updateServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateServiceInstanceArgs() []FakeCloudControllerClientUpdateServiceInstanceArgs { + fake.updateServiceInstanceMutex.RLock() + defer fake.updateServiceInstanceMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateServiceInstanceArgs, len(fake.updateServiceInstanceArgsForCall)) + copy(args, fake.updateServiceInstanceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -14731,10 +16980,7 @@ func (fake *FakeCloudControllerClient) UpdateServiceInstanceReturnsOnCall(i int, func (fake *FakeCloudControllerClient) UpdateServicePlanVisibility(arg1 string, arg2 resources.ServicePlanVisibility) (resources.ServicePlanVisibility, ccv3.Warnings, error) { fake.updateServicePlanVisibilityMutex.Lock() ret, specificReturn := fake.updateServicePlanVisibilityReturnsOnCall[len(fake.updateServicePlanVisibilityArgsForCall)] - fake.updateServicePlanVisibilityArgsForCall = append(fake.updateServicePlanVisibilityArgsForCall, struct { - arg1 string - arg2 resources.ServicePlanVisibility - }{arg1, arg2}) + fake.updateServicePlanVisibilityArgsForCall = append(fake.updateServicePlanVisibilityArgsForCall, FakeCloudControllerClientUpdateServicePlanVisibilityArgs{arg1, arg2}) stub := fake.UpdateServicePlanVisibilityStub fakeReturns := fake.updateServicePlanVisibilityReturns fake.recordInvocation("UpdateServicePlanVisibility", []interface{}{arg1, arg2}) @@ -14764,7 +17010,15 @@ func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityArgsForCall(i fake.updateServicePlanVisibilityMutex.RLock() defer fake.updateServicePlanVisibilityMutex.RUnlock() argsForCall := fake.updateServicePlanVisibilityArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityArgs() []FakeCloudControllerClientUpdateServicePlanVisibilityArgs { + fake.updateServicePlanVisibilityMutex.RLock() + defer fake.updateServicePlanVisibilityMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateServicePlanVisibilityArgs, len(fake.updateServicePlanVisibilityArgsForCall)) + copy(args, fake.updateServicePlanVisibilityArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityReturns(result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) { @@ -14799,9 +17053,7 @@ func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityReturnsOnCall( func (fake *FakeCloudControllerClient) UpdateSpace(arg1 resources.Space) (resources.Space, ccv3.Warnings, error) { fake.updateSpaceMutex.Lock() ret, specificReturn := fake.updateSpaceReturnsOnCall[len(fake.updateSpaceArgsForCall)] - fake.updateSpaceArgsForCall = append(fake.updateSpaceArgsForCall, struct { - arg1 resources.Space - }{arg1}) + fake.updateSpaceArgsForCall = append(fake.updateSpaceArgsForCall, FakeCloudControllerClientUpdateSpaceArgs{arg1}) stub := fake.UpdateSpaceStub fakeReturns := fake.updateSpaceReturns fake.recordInvocation("UpdateSpace", []interface{}{arg1}) @@ -14831,7 +17083,15 @@ func (fake *FakeCloudControllerClient) UpdateSpaceArgsForCall(i int) resources.S fake.updateSpaceMutex.RLock() defer fake.updateSpaceMutex.RUnlock() argsForCall := fake.updateSpaceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateSpaceArgs() []FakeCloudControllerClientUpdateSpaceArgs { + fake.updateSpaceMutex.RLock() + defer fake.updateSpaceMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSpaceArgs, len(fake.updateSpaceArgsForCall)) + copy(args, fake.updateSpaceArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSpaceReturns(result1 resources.Space, result2 ccv3.Warnings, result3 error) { @@ -14871,10 +17131,7 @@ func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifest(arg1 string, arg } fake.updateSpaceApplyManifestMutex.Lock() ret, specificReturn := fake.updateSpaceApplyManifestReturnsOnCall[len(fake.updateSpaceApplyManifestArgsForCall)] - fake.updateSpaceApplyManifestArgsForCall = append(fake.updateSpaceApplyManifestArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.updateSpaceApplyManifestArgsForCall = append(fake.updateSpaceApplyManifestArgsForCall, FakeCloudControllerClientUpdateSpaceApplyManifestArgs{arg1, arg2Copy}) stub := fake.UpdateSpaceApplyManifestStub fakeReturns := fake.updateSpaceApplyManifestReturns fake.recordInvocation("UpdateSpaceApplyManifest", []interface{}{arg1, arg2Copy}) @@ -14904,7 +17161,15 @@ func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestArgsForCall(i int fake.updateSpaceApplyManifestMutex.RLock() defer fake.updateSpaceApplyManifestMutex.RUnlock() argsForCall := fake.updateSpaceApplyManifestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestArgs() []FakeCloudControllerClientUpdateSpaceApplyManifestArgs { + fake.updateSpaceApplyManifestMutex.RLock() + defer fake.updateSpaceApplyManifestMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSpaceApplyManifestArgs, len(fake.updateSpaceApplyManifestArgsForCall)) + copy(args, fake.updateSpaceApplyManifestArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -14939,11 +17204,7 @@ func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturnsOnCall(i i func (fake *FakeCloudControllerClient) UpdateSpaceFeature(arg1 string, arg2 bool, arg3 string) (ccv3.Warnings, error) { fake.updateSpaceFeatureMutex.Lock() ret, specificReturn := fake.updateSpaceFeatureReturnsOnCall[len(fake.updateSpaceFeatureArgsForCall)] - fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, struct { - arg1 string - arg2 bool - arg3 string - }{arg1, arg2, arg3}) + fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, FakeCloudControllerClientUpdateSpaceFeatureArgs{arg1, arg2, arg3}) stub := fake.UpdateSpaceFeatureStub fakeReturns := fake.updateSpaceFeatureReturns fake.recordInvocation("UpdateSpaceFeature", []interface{}{arg1, arg2, arg3}) @@ -14973,7 +17234,15 @@ func (fake *FakeCloudControllerClient) UpdateSpaceFeatureArgsForCall(i int) (str fake.updateSpaceFeatureMutex.RLock() defer fake.updateSpaceFeatureMutex.RUnlock() argsForCall := fake.updateSpaceFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) UpdateSpaceFeatureArgs() []FakeCloudControllerClientUpdateSpaceFeatureArgs { + fake.updateSpaceFeatureMutex.RLock() + defer fake.updateSpaceFeatureMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSpaceFeatureArgs, len(fake.updateSpaceFeatureArgsForCall)) + copy(args, fake.updateSpaceFeatureArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSpaceFeatureReturns(result1 ccv3.Warnings, result2 error) { @@ -15005,10 +17274,7 @@ func (fake *FakeCloudControllerClient) UpdateSpaceFeatureReturnsOnCall(i int, re func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) { fake.updateSpaceIsolationSegmentRelationshipMutex.Lock() ret, specificReturn := fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall[len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)] - fake.updateSpaceIsolationSegmentRelationshipArgsForCall = append(fake.updateSpaceIsolationSegmentRelationshipArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.updateSpaceIsolationSegmentRelationshipArgsForCall = append(fake.updateSpaceIsolationSegmentRelationshipArgsForCall, FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs{arg1, arg2}) stub := fake.UpdateSpaceIsolationSegmentRelationshipStub fakeReturns := fake.updateSpaceIsolationSegmentRelationshipReturns fake.recordInvocation("UpdateSpaceIsolationSegmentRelationship", []interface{}{arg1, arg2}) @@ -15038,7 +17304,15 @@ func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipAr fake.updateSpaceIsolationSegmentRelationshipMutex.RLock() defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock() argsForCall := fake.updateSpaceIsolationSegmentRelationshipArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipArgs() []FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs { + fake.updateSpaceIsolationSegmentRelationshipMutex.RLock() + defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSpaceIsolationSegmentRelationshipArgs, len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)) + copy(args, fake.updateSpaceIsolationSegmentRelationshipArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) { @@ -15073,9 +17347,7 @@ func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipRe func (fake *FakeCloudControllerClient) UpdateSpaceQuota(arg1 resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) { fake.updateSpaceQuotaMutex.Lock() ret, specificReturn := fake.updateSpaceQuotaReturnsOnCall[len(fake.updateSpaceQuotaArgsForCall)] - fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, struct { - arg1 resources.SpaceQuota - }{arg1}) + fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, FakeCloudControllerClientUpdateSpaceQuotaArgs{arg1}) stub := fake.UpdateSpaceQuotaStub fakeReturns := fake.updateSpaceQuotaReturns fake.recordInvocation("UpdateSpaceQuota", []interface{}{arg1}) @@ -15105,7 +17377,15 @@ func (fake *FakeCloudControllerClient) UpdateSpaceQuotaArgsForCall(i int) resour fake.updateSpaceQuotaMutex.RLock() defer fake.updateSpaceQuotaMutex.RUnlock() argsForCall := fake.updateSpaceQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateSpaceQuotaArgs() []FakeCloudControllerClientUpdateSpaceQuotaArgs { + fake.updateSpaceQuotaMutex.RLock() + defer fake.updateSpaceQuotaMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateSpaceQuotaArgs, len(fake.updateSpaceQuotaArgsForCall)) + copy(args, fake.updateSpaceQuotaArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) { @@ -15140,11 +17420,7 @@ func (fake *FakeCloudControllerClient) UpdateSpaceQuotaReturnsOnCall(i int, resu func (fake *FakeCloudControllerClient) UpdateStack(arg1 string, arg2 string, arg3 string) (resources.Stack, ccv3.Warnings, error) { fake.updateStackMutex.Lock() ret, specificReturn := fake.updateStackReturnsOnCall[len(fake.updateStackArgsForCall)] - fake.updateStackArgsForCall = append(fake.updateStackArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.updateStackArgsForCall = append(fake.updateStackArgsForCall, FakeCloudControllerClientUpdateStackArgs{arg1, arg2, arg3}) stub := fake.UpdateStackStub fakeReturns := fake.updateStackReturns fake.recordInvocation("UpdateStack", []interface{}{arg1, arg2, arg3}) @@ -15174,7 +17450,15 @@ func (fake *FakeCloudControllerClient) UpdateStackArgsForCall(i int) (string, st fake.updateStackMutex.RLock() defer fake.updateStackMutex.RUnlock() argsForCall := fake.updateStackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeCloudControllerClient) UpdateStackArgs() []FakeCloudControllerClientUpdateStackArgs { + fake.updateStackMutex.RLock() + defer fake.updateStackMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateStackArgs, len(fake.updateStackArgsForCall)) + copy(args, fake.updateStackArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateStackReturns(result1 resources.Stack, result2 ccv3.Warnings, result3 error) { @@ -15209,9 +17493,7 @@ func (fake *FakeCloudControllerClient) UpdateStackReturnsOnCall(i int, result1 r func (fake *FakeCloudControllerClient) UpdateTaskCancel(arg1 string) (resources.Task, ccv3.Warnings, error) { fake.updateTaskCancelMutex.Lock() ret, specificReturn := fake.updateTaskCancelReturnsOnCall[len(fake.updateTaskCancelArgsForCall)] - fake.updateTaskCancelArgsForCall = append(fake.updateTaskCancelArgsForCall, struct { - arg1 string - }{arg1}) + fake.updateTaskCancelArgsForCall = append(fake.updateTaskCancelArgsForCall, FakeCloudControllerClientUpdateTaskCancelArgs{arg1}) stub := fake.UpdateTaskCancelStub fakeReturns := fake.updateTaskCancelReturns fake.recordInvocation("UpdateTaskCancel", []interface{}{arg1}) @@ -15241,7 +17523,15 @@ func (fake *FakeCloudControllerClient) UpdateTaskCancelArgsForCall(i int) string fake.updateTaskCancelMutex.RLock() defer fake.updateTaskCancelMutex.RUnlock() argsForCall := fake.updateTaskCancelArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeCloudControllerClient) UpdateTaskCancelArgs() []FakeCloudControllerClientUpdateTaskCancelArgs { + fake.updateTaskCancelMutex.RLock() + defer fake.updateTaskCancelMutex.RUnlock() + args := make([]FakeCloudControllerClientUpdateTaskCancelArgs, len(fake.updateTaskCancelArgsForCall)) + copy(args, fake.updateTaskCancelArgsForCall) + return args } func (fake *FakeCloudControllerClient) UpdateTaskCancelReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) { @@ -15281,12 +17571,7 @@ func (fake *FakeCloudControllerClient) UploadBitsPackage(arg1 resources.Package, } fake.uploadBitsPackageMutex.Lock() ret, specificReturn := fake.uploadBitsPackageReturnsOnCall[len(fake.uploadBitsPackageArgsForCall)] - fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, struct { - arg1 resources.Package - arg2 []ccv3.Resource - arg3 io.Reader - arg4 int64 - }{arg1, arg2Copy, arg3, arg4}) + fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, FakeCloudControllerClientUploadBitsPackageArgs{arg1, arg2Copy, arg3, arg4}) stub := fake.UploadBitsPackageStub fakeReturns := fake.uploadBitsPackageReturns fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4}) @@ -15316,7 +17601,15 @@ func (fake *FakeCloudControllerClient) UploadBitsPackageArgsForCall(i int) (reso fake.uploadBitsPackageMutex.RLock() defer fake.uploadBitsPackageMutex.RUnlock() argsForCall := fake.uploadBitsPackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) UploadBitsPackageArgs() []FakeCloudControllerClientUploadBitsPackageArgs { + fake.uploadBitsPackageMutex.RLock() + defer fake.uploadBitsPackageMutex.RUnlock() + args := make([]FakeCloudControllerClientUploadBitsPackageArgs, len(fake.uploadBitsPackageArgsForCall)) + copy(args, fake.uploadBitsPackageArgsForCall) + return args } func (fake *FakeCloudControllerClient) UploadBitsPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) { @@ -15351,12 +17644,7 @@ func (fake *FakeCloudControllerClient) UploadBitsPackageReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) UploadBuildpack(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv3.JobURL, ccv3.Warnings, error) { fake.uploadBuildpackMutex.Lock() ret, specificReturn := fake.uploadBuildpackReturnsOnCall[len(fake.uploadBuildpackArgsForCall)] - fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - }{arg1, arg2, arg3, arg4}) + fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, FakeCloudControllerClientUploadBuildpackArgs{arg1, arg2, arg3, arg4}) stub := fake.UploadBuildpackStub fakeReturns := fake.uploadBuildpackReturns fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3, arg4}) @@ -15386,7 +17674,15 @@ func (fake *FakeCloudControllerClient) UploadBuildpackArgsForCall(i int) (string fake.uploadBuildpackMutex.RLock() defer fake.uploadBuildpackMutex.RUnlock() argsForCall := fake.uploadBuildpackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) UploadBuildpackArgs() []FakeCloudControllerClientUploadBuildpackArgs { + fake.uploadBuildpackMutex.RLock() + defer fake.uploadBuildpackMutex.RUnlock() + args := make([]FakeCloudControllerClientUploadBuildpackArgs, len(fake.uploadBuildpackArgsForCall)) + copy(args, fake.uploadBuildpackArgsForCall) + return args } func (fake *FakeCloudControllerClient) UploadBuildpackReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -15421,12 +17717,7 @@ func (fake *FakeCloudControllerClient) UploadBuildpackReturnsOnCall(i int, resul func (fake *FakeCloudControllerClient) UploadDropletBits(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv3.JobURL, ccv3.Warnings, error) { fake.uploadDropletBitsMutex.Lock() ret, specificReturn := fake.uploadDropletBitsReturnsOnCall[len(fake.uploadDropletBitsArgsForCall)] - fake.uploadDropletBitsArgsForCall = append(fake.uploadDropletBitsArgsForCall, struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - }{arg1, arg2, arg3, arg4}) + fake.uploadDropletBitsArgsForCall = append(fake.uploadDropletBitsArgsForCall, FakeCloudControllerClientUploadDropletBitsArgs{arg1, arg2, arg3, arg4}) stub := fake.UploadDropletBitsStub fakeReturns := fake.uploadDropletBitsReturns fake.recordInvocation("UploadDropletBits", []interface{}{arg1, arg2, arg3, arg4}) @@ -15456,7 +17747,15 @@ func (fake *FakeCloudControllerClient) UploadDropletBitsArgsForCall(i int) (stri fake.uploadDropletBitsMutex.RLock() defer fake.uploadDropletBitsMutex.RUnlock() argsForCall := fake.uploadDropletBitsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeCloudControllerClient) UploadDropletBitsArgs() []FakeCloudControllerClientUploadDropletBitsArgs { + fake.uploadDropletBitsMutex.RLock() + defer fake.uploadDropletBitsMutex.RUnlock() + args := make([]FakeCloudControllerClientUploadDropletBitsArgs, len(fake.uploadDropletBitsArgsForCall)) + copy(args, fake.uploadDropletBitsArgsForCall) + return args } func (fake *FakeCloudControllerClient) UploadDropletBitsReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { @@ -15491,10 +17790,7 @@ func (fake *FakeCloudControllerClient) UploadDropletBitsReturnsOnCall(i int, res func (fake *FakeCloudControllerClient) UploadPackage(arg1 resources.Package, arg2 string) (resources.Package, ccv3.Warnings, error) { fake.uploadPackageMutex.Lock() ret, specificReturn := fake.uploadPackageReturnsOnCall[len(fake.uploadPackageArgsForCall)] - fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, struct { - arg1 resources.Package - arg2 string - }{arg1, arg2}) + fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, FakeCloudControllerClientUploadPackageArgs{arg1, arg2}) stub := fake.UploadPackageStub fakeReturns := fake.uploadPackageReturns fake.recordInvocation("UploadPackage", []interface{}{arg1, arg2}) @@ -15524,7 +17820,15 @@ func (fake *FakeCloudControllerClient) UploadPackageArgsForCall(i int) (resource fake.uploadPackageMutex.RLock() defer fake.uploadPackageMutex.RUnlock() argsForCall := fake.uploadPackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeCloudControllerClient) UploadPackageArgs() []FakeCloudControllerClientUploadPackageArgs { + fake.uploadPackageMutex.RLock() + defer fake.uploadPackageMutex.RUnlock() + args := make([]FakeCloudControllerClientUploadPackageArgs, len(fake.uploadPackageArgsForCall)) + copy(args, fake.uploadPackageArgsForCall) + return args } func (fake *FakeCloudControllerClient) UploadPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) { @@ -15559,8 +17863,7 @@ func (fake *FakeCloudControllerClient) UploadPackageReturnsOnCall(i int, result1 func (fake *FakeCloudControllerClient) WhoAmI() (resources.K8sUser, ccv3.Warnings, error) { fake.whoAmIMutex.Lock() ret, specificReturn := fake.whoAmIReturnsOnCall[len(fake.whoAmIArgsForCall)] - fake.whoAmIArgsForCall = append(fake.whoAmIArgsForCall, struct { - }{}) + fake.whoAmIArgsForCall = append(fake.whoAmIArgsForCall, struct{}{}) stub := fake.WhoAmIStub fakeReturns := fake.whoAmIReturns fake.recordInvocation("WhoAmI", []interface{}{}) @@ -15625,9 +17928,18 @@ func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} return copiedInvocations } +func (fake *FakeCloudControllerClient) CallOrder() []string { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + order := make([]string, len(fake.callOrder)) + copy(order, fake.callOrder) + return order +} + func (fake *FakeCloudControllerClient) recordInvocation(key string, args []interface{}) { fake.invocationsMutex.Lock() defer fake.invocationsMutex.Unlock() + fake.callOrder = append(fake.callOrder, key) if fake.invocations == nil { fake.invocations = map[string][][]interface{}{} } diff --git a/api/cloudcontroller/ccv3/internal/api_routes.go b/api/cloudcontroller/ccv3/internal/api_routes.go index 5f7d486914..c4f14b70d8 100644 --- a/api/cloudcontroller/ccv3/internal/api_routes.go +++ b/api/cloudcontroller/ccv3/internal/api_routes.go @@ -9,6 +9,12 @@ import "net/http" // If the request returns a single entity by GUID, use the singular (for example // /v3/organizations/:organization_guid is GetOrganization). const ( + GetServiceAccountRequest = "GetServiceAccount" + DeleteServiceAccountRequest = "DeleteServiceAccount" + PatchServiceAccountRequest = "PatchServiceAccount" + PatchApplicationServiceAccountRequest = "PatchApplicationServiceAccount" + GetServiceAccountsRequest = "GetServiceAccounts" + PostServiceAccountsRequest = "PostServiceAccounts" DeleteRoutePolicyRequest = "DeleteRoutePolicyRequest" DeleteApplicationProcessInstanceRequest = "DeleteApplicationProcessInstance" DeleteApplicationRequest = "DeleteApplication" @@ -254,6 +260,12 @@ var APIRoutes = map[string]Route{ PatchFeatureFlagRequest: {Path: "/v3/feature_flags/:name", Method: http.MethodPatch}, GetIsolationSegmentsRequest: {Path: "/v3/isolation_segments", Method: http.MethodGet}, PostIsolationSegmentsRequest: {Path: "/v3/isolation_segments", Method: http.MethodPost}, + PostServiceAccountsRequest: {Path: "/v3/service_accounts", Method: http.MethodPost}, + GetServiceAccountsRequest: {Path: "/v3/service_accounts", Method: http.MethodGet}, + GetServiceAccountRequest: {Path: "/v3/service_accounts/:service_account_guid", Method: http.MethodGet}, + DeleteServiceAccountRequest: {Path: "/v3/service_accounts/:service_account_guid", Method: http.MethodDelete}, + PatchServiceAccountRequest: {Path: "/v3/service_accounts/:service_account_guid", Method: http.MethodPatch}, + PatchApplicationServiceAccountRequest: {Path: "/v3/apps/:app_guid/relationships/service_account", Method: http.MethodPatch}, DeleteIsolationSegmentRequest: {Path: "/v3/isolation_segments/:isolation_segment_guid", Method: http.MethodDelete}, GetIsolationSegmentRequest: {Path: "/v3/isolation_segments/:isolation_segment_guid", Method: http.MethodGet}, GetIsolationSegmentOrganizationsRequest: {Path: "/v3/isolation_segments/:isolation_segment_guid/organizations", Method: http.MethodGet}, diff --git a/api/cloudcontroller/ccv3/service_account.go b/api/cloudcontroller/ccv3/service_account.go new file mode 100644 index 0000000000..ab1b91d8a0 --- /dev/null +++ b/api/cloudcontroller/ccv3/service_account.go @@ -0,0 +1,57 @@ +package ccv3 + +import ( + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" + "code.cloudfoundry.org/cli/v9/resources" +) + +func (client *Client) GetServiceAccount(guid string) (resources.ServiceAccount, Warnings, error) { + var account resources.ServiceAccount + _, warnings, err := client.MakeRequest(RequestParams{RequestName: internal.GetServiceAccountRequest, URIParams: internal.Params{"service_account_guid": guid}, ResponseBody: &account}) + return account, warnings, err +} + +func (client *Client) DeleteServiceAccount(guid string) (JobURL, Warnings, error) { + return client.MakeRequest(RequestParams{RequestName: internal.DeleteServiceAccountRequest, URIParams: internal.Params{"service_account_guid": guid}}) +} + +func (client *Client) UpdateServiceAccountEnabled(guid string, enabled bool) (JobURL, Warnings, error) { + return client.MakeRequest(RequestParams{RequestName: internal.PatchServiceAccountRequest, URIParams: internal.Params{"service_account_guid": guid}, RequestBody: struct { + Enabled bool `json:"enabled"` + }{enabled}}) +} + +func (client *Client) UpdateApplicationServiceAccount(appGUID string, relationship resources.Relationship) (JobURL, Warnings, error) { + return client.MakeRequest(RequestParams{RequestName: internal.PatchApplicationServiceAccountRequest, URIParams: internal.Params{"app_guid": appGUID}, RequestBody: relationship}) +} + +func (client *Client) GetServiceAccounts(query ...Query) ([]resources.ServiceAccount, Warnings, error) { + var accounts []resources.ServiceAccount + _, warnings, err := client.MakeListRequest(RequestParams{ + RequestName: internal.GetServiceAccountsRequest, + Query: query, + ResponseBody: resources.ServiceAccount{}, + AppendToList: func(item interface{}) error { + accounts = append(accounts, item.(resources.ServiceAccount)) + return nil + }, + }) + return accounts, warnings, err +} + +func (client *Client) CreateServiceAccount(account resources.ServiceAccount) (resources.ServiceAccount, Warnings, error) { + // Only platform-independent creation inputs may be sent; identity and + // provisioning state are supplied by CAPI. + request := struct { + Name string `json:"name"` + Description string `json:"description,omitempty"` + Relationships resources.Relationships `json:"relationships"` + }{account.Name, account.Description, account.Relationships} + var response resources.ServiceAccount + _, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.PostServiceAccountsRequest, + RequestBody: request, + ResponseBody: &response, + }) + return response, warnings, err +} diff --git a/api/cloudcontroller/ccv3/service_account_lifecycle_test.go b/api/cloudcontroller/ccv3/service_account_lifecycle_test.go new file mode 100644 index 0000000000..fe6cf98f6f --- /dev/null +++ b/api/cloudcontroller/ccv3/service_account_lifecycle_test.go @@ -0,0 +1,92 @@ +package ccv3_test + +import ( + "net/http" + + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccerror" + . "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/ghttp" +) + +var _ = Describe("Service Account Lifecycle API", func() { + var client *Client + BeforeEach(func() { client, _ = NewTestClient() }) + + It("fetches account detail by immutable GUID", func() { + server.AppendHandlers(CombineHandlers(VerifyRequest(http.MethodGet, "/v3/service_accounts/account-guid"), + RespondWith(http.StatusOK, `{"guid":"account-guid","name":"workers","description":"Workers","enabled":false,"status":"ready"}`, http.Header{"X-Cf-Warnings": {"detail warning"}}))) + account, warnings, err := client.GetServiceAccount("account-guid") + Expect(err).NotTo(HaveOccurred()) + Expect(account).To(Equal(resources.ServiceAccount{GUID: "account-guid", Name: "workers", Description: "Workers", Enabled: false, Status: "ready"})) + Expect(warnings).To(ConsistOf("detail warning")) + }) + + DescribeTable("encodes lifecycle changes and returns the asynchronous job location", func(operation, method, path, body string) { + handlers := []http.HandlerFunc{VerifyRequest(method, path)} + if body != "" { + handlers = append(handlers, VerifyJSON(body)) + } + handlers = append(handlers, RespondWith(http.StatusAccepted, "", http.Header{"Location": {server.URL() + "/v3/jobs/job-guid"}, "X-Cf-Warnings": {"operation warning"}})) + server.AppendHandlers(CombineHandlers(handlers...)) + var job JobURL + var warnings Warnings + var err error + switch operation { + case "delete": + job, warnings, err = client.DeleteServiceAccount("account-guid") + case "enable": + job, warnings, err = client.UpdateServiceAccountEnabled("account-guid", true) + case "disable": + job, warnings, err = client.UpdateServiceAccountEnabled("account-guid", false) + case "bind": + job, warnings, err = client.UpdateApplicationServiceAccount("app-guid", resources.Relationship{GUID: "account-guid"}) + case "unbind": + job, warnings, err = client.UpdateApplicationServiceAccount("app-guid", resources.Relationship{}) + } + Expect(err).NotTo(HaveOccurred()) + Expect(job).To(Equal(JobURL(server.URL() + "/v3/jobs/job-guid"))) + Expect(warnings).To(ConsistOf("operation warning")) + }, + Entry("delete", "delete", http.MethodDelete, "/v3/service_accounts/account-guid", ""), + Entry("enable", "enable", http.MethodPatch, "/v3/service_accounts/account-guid", `{"enabled":true}`), + Entry("disable", "disable", http.MethodPatch, "/v3/service_accounts/account-guid", `{"enabled":false}`), + Entry("bind", "bind", http.MethodPatch, "/v3/apps/app-guid/relationships/service_account", `{"data":{"guid":"account-guid"}}`), + Entry("unbind", "unbind", http.MethodPatch, "/v3/apps/app-guid/relationships/service_account", `{"data":null}`), + ) + + It("supports synchronous unbinding and retains restart warnings", func() { + server.AppendHandlers(CombineHandlers(VerifyRequest(http.MethodPatch, "/v3/apps/app-guid/relationships/service_account"), VerifyJSON(`{"data":null}`), + RespondWith(http.StatusOK, `{"data":null}`, http.Header{"X-Cf-Warnings": {"Restart workers"}}))) + job, warnings, err := client.UpdateApplicationServiceAccount("app-guid", resources.Relationship{}) + Expect(err).NotTo(HaveOccurred()) + Expect(job).To(BeEmpty()) + Expect(warnings).To(ConsistOf("Restart workers")) + }) + + DescribeTable("preserves server errors and warnings", func(operation, method, path string) { + server.AppendHandlers(CombineHandlers(VerifyRequest(method, path), RespondWith(http.StatusForbidden, + `{"errors":[{"code":10003,"title":"CF-NotAuthorized","detail":"denied"}]}`, http.Header{"X-Cf-Warnings": {"warning"}}))) + var warnings Warnings + var err error + switch operation { + case "show": + _, warnings, err = client.GetServiceAccount("account-guid") + case "delete": + _, warnings, err = client.DeleteServiceAccount("account-guid") + case "enable": + _, warnings, err = client.UpdateServiceAccountEnabled("account-guid", true) + case "bind": + _, warnings, err = client.UpdateApplicationServiceAccount("app-guid", resources.Relationship{GUID: "account-guid"}) + } + Expect(err).To(MatchError(ccerror.ForbiddenError{Message: "denied"})) + Expect(warnings).To(ConsistOf("warning")) + }, + Entry("show denial", "show", http.MethodGet, "/v3/service_accounts/account-guid"), + Entry("delete denial", "delete", http.MethodDelete, "/v3/service_accounts/account-guid"), + Entry("enable denial", "enable", http.MethodPatch, "/v3/service_accounts/account-guid"), + Entry("assignment denial", "bind", http.MethodPatch, "/v3/apps/app-guid/relationships/service_account"), + ) +}) diff --git a/api/cloudcontroller/ccv3/service_account_test.go b/api/cloudcontroller/ccv3/service_account_test.go new file mode 100644 index 0000000000..a24c705871 --- /dev/null +++ b/api/cloudcontroller/ccv3/service_account_test.go @@ -0,0 +1,90 @@ +package ccv3_test + +import ( + "fmt" + "net/http" + + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccerror" + . "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/ghttp" +) + +var _ = Describe("Service Accounts", func() { + var client *Client + BeforeEach(func() { client, _ = NewTestClient() }) + + Describe("GetServiceAccounts", func() { + It("filters by owning space, follows pagination and accumulates warnings", func() { + server.AppendHandlers( + CombineHandlers(VerifyRequest(http.MethodGet, "/v3/service_accounts", "space_guids=space-guid"), + RespondWith(http.StatusOK, fmt.Sprintf(`{"pagination":{"next":{"href":"%s/v3/service_accounts?space_guids=space-guid&page=2"}},"resources":[{"guid":"one","name":"first-account","enabled":false,"status":"unprovisioned"}]}`, server.URL()), http.Header{"X-Cf-Warnings": {"first warning"}})), + CombineHandlers(VerifyRequest(http.MethodGet, "/v3/service_accounts", "space_guids=space-guid&page=2"), + RespondWith(http.StatusOK, `{"pagination":{"next":null},"resources":[{"guid":"two","name":"second-account","enabled":true,"status":"ready"}]}`, http.Header{"X-Cf-Warnings": {"second warning"}})), + ) + accounts, warnings, err := client.GetServiceAccounts(Query{Key: SpaceGUIDFilter, Values: []string{"space-guid"}}) + Expect(err).NotTo(HaveOccurred()) + Expect(accounts).To(Equal([]resources.ServiceAccount{ + {GUID: "one", Name: "first-account", Enabled: false, Status: "unprovisioned"}, + {GUID: "two", Name: "second-account", Enabled: true, Status: "ready"}, + })) + Expect(warnings).To(ConsistOf("first warning", "second warning")) + Expect(server.ReceivedRequests()).To(HaveLen(2)) + }) + It("propagates list denial and warnings", func() { + server.AppendHandlers(CombineHandlers(VerifyRequest(http.MethodGet, "/v3/service_accounts"), + RespondWith(http.StatusForbidden, `{"errors":[{"code":10003,"title":"CF-NotAuthorized","detail":"denied"}]}`, http.Header{"X-Cf-Warnings": {"warning"}}))) + _, warnings, err := client.GetServiceAccounts() + Expect(err).To(MatchError(ccerror.ForbiddenError{Message: "denied"})) + Expect(warnings).To(ConsistOf("warning")) + }) + }) + + Describe("CreateServiceAccount", func() { + It("posts only account input and space ownership and returns the platform identity and warnings", func() { + server.AppendHandlers(CombineHandlers( + VerifyRequest(http.MethodPost, "/v3/service_accounts"), + VerifyJSON(`{"name":"shared-worker","description":"Background workers","relationships":{"space":{"data":{"guid":"space-guid"}}}}`), + RespondWith(http.StatusCreated, `{"guid":"account-guid","name":"shared-worker","description":"Background workers","client_id":"cf:service-account:shared-worker","certificate_dns_san":"shared-worker.svc.identity","enabled":true,"status":"unprovisioned","relationships":{"space":{"data":{"guid":"space-guid"}}}}`, http.Header{"X-Cf-Warnings": {"account warning"}}), + )) + account, warnings, err := client.CreateServiceAccount(resources.ServiceAccount{ + Name: "shared-worker", Description: "Background workers", + Relationships: resources.Relationships{constant.RelationshipTypeSpace: {GUID: "space-guid"}}, + // These are response-only fields, never client-controlled creation input. + GUID: "injected-guid", ClientID: "injected-client", CertificateDNSSAN: "injected-san", Status: "ready", Enabled: true, + }) + Expect(err).NotTo(HaveOccurred()) + Expect(server.ReceivedRequests()).To(HaveLen(1)) + Expect(warnings).To(ConsistOf("account warning")) + Expect(account).To(Equal(resources.ServiceAccount{ + GUID: "account-guid", Name: "shared-worker", Description: "Background workers", + ClientID: "cf:service-account:shared-worker", CertificateDNSSAN: "shared-worker.svc.identity", Enabled: true, Status: "unprovisioned", + Relationships: resources.Relationships{constant.RelationshipTypeSpace: {GUID: "space-guid"}}, + })) + }) + + It("omits an unspecified description", func() { + server.AppendHandlers(CombineHandlers( + VerifyRequest(http.MethodPost, "/v3/service_accounts"), + VerifyJSON(`{"name":"shared-worker","relationships":{"space":{"data":{"guid":"space-guid"}}}}`), + RespondWith(http.StatusCreated, `{"guid":"account-guid","name":"shared-worker"}`), + )) + _, _, err := client.CreateServiceAccount(resources.ServiceAccount{Name: "shared-worker", Relationships: resources.Relationships{constant.RelationshipTypeSpace: {GUID: "space-guid"}}}) + Expect(err).NotTo(HaveOccurred()) + Expect(server.ReceivedRequests()).To(HaveLen(1)) + }) + + It("returns CAPI denial and warnings without treating it as success", func() { + server.AppendHandlers(CombineHandlers( + VerifyRequest(http.MethodPost, "/v3/service_accounts"), + RespondWith(http.StatusForbidden, `{"errors":[{"code":10003,"title":"CF-NotAuthorized","detail":"You are not authorized to perform the requested action"}]}`, http.Header{"X-Cf-Warnings": {"denial warning"}}), + )) + _, warnings, err := client.CreateServiceAccount(resources.ServiceAccount{Name: "shared-worker"}) + Expect(err).To(MatchError(ccerror.ForbiddenError{Message: "You are not authorized to perform the requested action"})) + Expect(warnings).To(ConsistOf("denial warning")) + }) + }) +}) diff --git a/command/common/command_list_v7.go b/command/common/command_list_v7.go index 1070a5b8e1..a3fa187d44 100644 --- a/command/common/command_list_v7.go +++ b/command/common/command_list_v7.go @@ -11,7 +11,14 @@ var Commands commandList var ShouldFallbackToLegacy = false type commandList struct { - VerboseOrVersion bool `short:"v" long:"version" description:"verbose and version flag"` + ServiceAccount v7.ServiceAccountCommand `command:"service-account" description:"Show service account details in the target space"` + DeleteServiceAccount v7.DeleteServiceAccountCommand `command:"delete-service-account" description:"Delete an unused service account and retain its name reservation"` + EnableServiceAccount v7.EnableServiceAccountCommand `command:"enable-service-account" description:"Enable new token issuance for a service account"` + DisableServiceAccount v7.DisableServiceAccountCommand `command:"disable-service-account" description:"Disable new token issuance for a service account"` + BindServiceAccount v7.BindServiceAccountCommand `command:"bind-service-account" description:"Assign a service account to an app; requires restart"` + UnbindServiceAccount v7.UnbindServiceAccountCommand `command:"unbind-service-account" description:"Remove an app's service account assignment; requires restart"` + ServiceAccounts v7.ServiceAccountsCommand `command:"service-accounts" description:"List service accounts in the target space"` + VerboseOrVersion bool `short:"v" long:"version" description:"verbose and version flag"` V3Push v7.PushCommand `command:"v3-push" description:"Push a new app or sync changes to an existing app" hidden:"true"` @@ -49,6 +56,7 @@ type commandList struct { UpdateRoute v7.UpdateRouteCommand `command:"update-route" description:"Update a route by route specific options, e.g. load balancing algorithm"` CreateSecurityGroup v7.CreateSecurityGroupCommand `command:"create-security-group" description:"Create a security group"` CreateService v7.CreateServiceCommand `command:"create-service" alias:"cs" description:"Create a service instance"` + CreateServiceAccount v7.CreateServiceAccountCommand `command:"create-service-account" description:"Create a service account in the target space"` CreateServiceBroker v7.CreateServiceBrokerCommand `command:"create-service-broker" alias:"csb" description:"Create a service broker"` CreateServiceKey v7.CreateServiceKeyCommand `command:"create-service-key" alias:"csk" description:"Create key for a service instance"` CreateSharedDomain v7.CreateSharedDomainCommand `command:"create-shared-domain" description:"Create a domain that can be used by all orgs (admin-only)"` diff --git a/command/common/command_list_v7_test.go b/command/common/command_list_v7_test.go index 88c2b05e16..29afb26560 100644 --- a/command/common/command_list_v7_test.go +++ b/command/common/command_list_v7_test.go @@ -7,6 +7,12 @@ import ( ) var _ = Describe("commandList", func() { + It("registers service-accounts as a native command", func() { + Expect(Commands.HasCommand("service-accounts")).To(BeTrue()) + }) + It("registers create-service-account as a native command", func() { + Expect(Commands.HasCommand("create-service-account")).To(BeTrue()) + }) Describe("HasCommand", func() { When("the command name exists", func() { It("returns true", func() { diff --git a/command/common/internal/help_all_display.go b/command/common/internal/help_all_display.go index b6bcd70f14..01b5b05ec9 100644 --- a/command/common/internal/help_all_display.go +++ b/command/common/internal/help_all_display.go @@ -39,6 +39,15 @@ var HelpCategoryList = []HelpCategory{ {"share-service", "unshare-service"}, }, }, + { + CategoryName: "SERVICE ACCOUNTS:", + CommandList: [][]string{ + {"service-accounts", "create-service-account"}, + {"service-account", "delete-service-account"}, + {"enable-service-account", "disable-service-account"}, + {"bind-service-account", "unbind-service-account"}, + }, + }, { CategoryName: "ORGS:", CommandList: [][]string{ diff --git a/command/common/internal/help_common_display_v7.go b/command/common/internal/help_common_display_v7.go index e5878971c0..e5219b6dc1 100644 --- a/command/common/internal/help_common_display_v7.go +++ b/command/common/internal/help_common_display_v7.go @@ -35,6 +35,16 @@ var CommonHelpCategoryList = []HelpCategory{ }, }, + { + CategoryName: "Service accounts:", + CommandList: [][]string{ + {"service-accounts", "create-service-account"}, + {"service-account", "delete-service-account"}, + {"enable-service-account", "disable-service-account"}, + {"bind-service-account", "unbind-service-account"}, + }, + }, + { CategoryName: "Route and domain management:", CommandList: [][]string{ diff --git a/command/common/service_accounts_help_test.go b/command/common/service_accounts_help_test.go new file mode 100644 index 0000000000..181707944f --- /dev/null +++ b/command/common/service_accounts_help_test.go @@ -0,0 +1,31 @@ +package common_test + +import ( + "code.cloudfoundry.org/cli/v9/actor/sharedaction" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + "code.cloudfoundry.org/cli/v9/command/common" + "code.cloudfoundry.org/cli/v9/util/ui" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("service account help discovery", func() { + DescribeTable("shows both service-account commands in a dedicated category", func(all bool, heading string) { + config := new(commandfakes.FakeConfig) + config.BinaryNameReturns("cf") + testUI := ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + cmd := common.HelpCommand{UI: testUI, Config: config, Actor: sharedaction.NewActor(config), AllCommands: all} + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(testUI.Out).To(Say(heading)) + Expect(testUI.Out).To(Say("service-accounts")) + Expect(testUI.Out).To(Say("create-service-account")) + for _, name := range []string{"service-account", "delete-service-account", "enable-service-account", "disable-service-account", "bind-service-account", "unbind-service-account"} { + Expect(common.Commands.HasCommand(name)).To(BeTrue(), name) + Expect(testUI.Out).To(Say(name)) + } + }, + Entry("default help", false, "Service accounts:"), + Entry("full help", true, "SERVICE ACCOUNTS:"), + ) +}) diff --git a/command/v7/actor.go b/command/v7/actor.go index f1c954b418..e29dedfcc6 100644 --- a/command/v7/actor.go +++ b/command/v7/actor.go @@ -21,6 +21,12 @@ import ( //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . Actor type Actor interface { + GetServiceAccountByNameAndSpace(name, spaceGUID string) (resources.ServiceAccount, v7action.Warnings, error) + DeleteServiceAccountByNameAndSpace(name, spaceGUID string) (v7action.Warnings, error) + SetServiceAccountEnabledByNameAndSpace(name, spaceGUID string, enabled bool) (v7action.Warnings, error) + BindServiceAccountByNameAndSpace(appName, accountName, spaceGUID string) (v7action.Warnings, error) + UnbindServiceAccountByAppNameAndSpace(appName, spaceGUID string) (v7action.Warnings, error) + GetServiceAccountsInSpace(spaceGUID string) ([]resources.ServiceAccount, v7action.Warnings, error) ApplyOrganizationQuotaByName(quotaName string, orgGUID string) (v7action.Warnings, error) ApplySpaceQuotaByName(quotaName string, spaceGUID string, orgGUID string) (v7action.Warnings, error) AddRoutePolicy(domainName, source, hostname, path string) (v7action.Warnings, error) @@ -41,6 +47,7 @@ type Actor interface { CreateDockerPackageByApplication(appGUID string, dockerImageCredentials v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) CreateDockerPackageByApplicationNameAndSpace(appName string, spaceGUID string, dockerImageCredentials v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) CreateIsolationSegmentByName(isolationSegment resources.IsolationSegment) (v7action.Warnings, error) + CreateServiceAccountInSpace(name, description, spaceGUID string) (resources.ServiceAccount, v7action.Warnings, error) CreateManagedServiceInstance(managedServiceInstanceParams v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) CreateOrgRole(roleType constant.RoleType, orgGUID string, userNameOrGUID string, userOrigin string, isClient bool) (v7action.Warnings, error) CreateOrganization(orgName string) (resources.Organization, v7action.Warnings, error) diff --git a/command/v7/create_service_account_command.go b/command/v7/create_service_account_command.go new file mode 100644 index 0000000000..0357d72c19 --- /dev/null +++ b/command/v7/create_service_account_command.go @@ -0,0 +1,38 @@ +package v7 + +type CreateServiceAccountCommand struct { + BaseCommand + RequiredArgs struct { + Name string `positional-arg-name:"SERVICE_ACCOUNT_NAME" required:"yes"` + } `positional-args:"yes"` + Description string `long:"description" description:"Description of the service account"` + usage interface{} `usage:"CF_NAME create-service-account SERVICE_ACCOUNT_NAME [--description DESCRIPTION]"` +} + +func (cmd CreateServiceAccountCommand) Execute(args []string) error { + if err := cmd.SharedActor.CheckTarget(true, true); err != nil { + return err + } + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + cmd.UI.DisplayTextWithFlavor("Creating service account {{.Name}} in org {{.Org}} / space {{.Space}} as {{.User}}...", map[string]interface{}{ + "Name": cmd.RequiredArgs.Name, + "Org": cmd.Config.TargetedOrganization().Name, + "Space": cmd.Config.TargetedSpace().Name, + "User": user.Name, + }) + account, warnings, err := cmd.Actor.CreateServiceAccountInSpace(cmd.RequiredArgs.Name, cmd.Description, cmd.Config.TargetedSpace().GUID) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + cmd.UI.DisplayOK() + cmd.UI.DisplayNewline() + cmd.UI.DisplayText("Client ID: {{.ClientID}}\nCertificate DNS SAN: {{.SAN}}\nStatus: {{.Status}}", map[string]interface{}{ + "ClientID": account.ClientID, "SAN": account.CertificateDNSSAN, "Status": account.Status, + }) + cmd.UI.DisplayText("Provisioning occurs on first bind. Account roles must be granted explicitly.") + return nil +} diff --git a/command/v7/create_service_account_command_test.go b/command/v7/create_service_account_command_test.go new file mode 100644 index 0000000000..bca7f05881 --- /dev/null +++ b/command/v7/create_service_account_command_test.go @@ -0,0 +1,77 @@ +package v7_test + +import ( + "errors" + + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + . "code.cloudfoundry.org/cli/v9/command/v7" + "code.cloudfoundry.org/cli/v9/command/v7/v7fakes" + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/configv3" + "code.cloudfoundry.org/cli/v9/util/ui" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("create-service-account Command", func() { + var cmd CreateServiceAccountCommand + var actor *v7fakes.FakeActor + var shared *commandfakes.FakeSharedActor + var testUI *ui.UI + BeforeEach(func() { + actor = new(v7fakes.FakeActor) + shared = new(commandfakes.FakeSharedActor) + config := new(commandfakes.FakeConfig) + config.TargetedSpaceReturns(configv3.Space{GUID: "space-guid", Name: "workers"}) + config.TargetedOrganizationReturns(configv3.Organization{Name: "poc"}) + actor.GetCurrentUserReturns(configv3.User{Name: "operator"}, nil) + actor.CreateServiceAccountInSpaceReturns(resources.ServiceAccount{ + Name: "shared-worker", ClientID: "cf:service-account:shared-worker", CertificateDNSSAN: "shared-worker.svc.identity", Status: "unprovisioned", + }, v7action.Warnings{"account warning"}, nil) + testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + cmd = CreateServiceAccountCommand{BaseCommand: BaseCommand{Actor: actor, SharedActor: shared, Config: config, UI: testUI}, Description: "Workers"} + cmd.RequiredArgs.Name = "shared-worker" + }) + It("creates in the targeted space, prints identity and accurately describes first-bind provisioning", func() { + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(shared.CheckTargetCallCount()).To(Equal(1)) + org, space := shared.CheckTargetArgsForCall(0) + Expect(org).To(BeTrue()) + Expect(space).To(BeTrue()) + Expect(actor.CreateServiceAccountInSpaceCallCount()).To(Equal(1)) + name, description, guid := actor.CreateServiceAccountInSpaceArgsForCall(0) + Expect(name).To(Equal("shared-worker")) + Expect(description).To(Equal("Workers")) + Expect(guid).To(Equal("space-guid")) + Expect(testUI.Out).To(Say("Creating service account shared-worker in org poc / space workers as operator")) + Expect(testUI.Out).To(Say("OK")) + Expect(testUI.Out).To(Say("cf:service-account:shared-worker")) + Expect(testUI.Out).To(Say("shared-worker.svc.identity")) + Expect(testUI.Out).To(Say("unprovisioned")) + Expect(testUI.Out).To(Say("Provisioning occurs on first bind")) + Expect(testUI.Err).To(Say("account warning")) + }) + It("fails before creation when login or the space target is missing", func() { + missing := errors.New("no space targeted") + shared.CheckTargetReturns(missing) + Expect(cmd.Execute(nil)).To(MatchError(missing)) + Expect(actor.GetCurrentUserCallCount()).To(BeZero()) + Expect(actor.CreateServiceAccountInSpaceCallCount()).To(BeZero()) + }) + It("fails before creation when the current user cannot be resolved", func() { + failed := errors.New("user unavailable") + actor.GetCurrentUserReturns(configv3.User{}, failed) + Expect(cmd.Execute(nil)).To(MatchError(failed)) + Expect(actor.CreateServiceAccountInSpaceCallCount()).To(BeZero()) + }) + It("displays warnings and returns a creation error without printing OK or a fabricated identity", func() { + denied := errors.New("not authorized") + actor.CreateServiceAccountInSpaceReturns(resources.ServiceAccount{}, v7action.Warnings{"denial warning"}, denied) + Expect(cmd.Execute(nil)).To(MatchError(denied)) + Expect(testUI.Err).To(Say("denial warning")) + Expect(testUI.Out).NotTo(Say("OK")) + Expect(testUI.Out).NotTo(Say("cf:service-account:")) + }) +}) diff --git a/command/v7/service_account_lifecycle_commands.go b/command/v7/service_account_lifecycle_commands.go new file mode 100644 index 0000000000..f4f5dfc690 --- /dev/null +++ b/command/v7/service_account_lifecycle_commands.go @@ -0,0 +1,168 @@ +package v7 + +import ( + "strconv" + + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/util/ui" +) + +type serviceAccountNameArgs struct { + Name string `positional-arg-name:"SERVICE_ACCOUNT_NAME" required:"yes"` +} + +type ServiceAccountCommand struct { + BaseCommand + RequiredArgs serviceAccountNameArgs `positional-args:"yes"` + usage interface{} `usage:"CF_NAME service-account SERVICE_ACCOUNT_NAME"` + relatedCommands interface{} `related_commands:"service-accounts, bind-service-account, enable-service-account, disable-service-account"` +} + +type DeleteServiceAccountCommand struct { + BaseCommand + RequiredArgs serviceAccountNameArgs `positional-args:"yes"` + Force bool `short:"f" description:"Force deletion without confirmation"` + usage interface{} `usage:"CF_NAME delete-service-account SERVICE_ACCOUNT_NAME [-f]"` + relatedCommands interface{} `related_commands:"service-accounts, unbind-service-account"` +} + +type EnableServiceAccountCommand struct { + BaseCommand + RequiredArgs serviceAccountNameArgs `positional-args:"yes"` + usage interface{} `usage:"CF_NAME enable-service-account SERVICE_ACCOUNT_NAME"` + relatedCommands interface{} `related_commands:"service-account, disable-service-account"` +} + +type DisableServiceAccountCommand struct { + BaseCommand + RequiredArgs serviceAccountNameArgs `positional-args:"yes"` + usage interface{} `usage:"CF_NAME disable-service-account SERVICE_ACCOUNT_NAME"` + relatedCommands interface{} `related_commands:"service-account, enable-service-account"` +} + +type BindServiceAccountCommand struct { + BaseCommand + RequiredArgs struct { + AppName string `positional-arg-name:"APP_NAME" required:"yes"` + AccountName string `positional-arg-name:"SERVICE_ACCOUNT_NAME" required:"yes"` + } `positional-args:"yes"` + usage interface{} `usage:"CF_NAME bind-service-account APP_NAME SERVICE_ACCOUNT_NAME"` + relatedCommands interface{} `related_commands:"service-accounts, unbind-service-account, restart"` +} + +type UnbindServiceAccountCommand struct { + BaseCommand + RequiredArgs struct { + AppName string `positional-arg-name:"APP_NAME" required:"yes"` + } `positional-args:"yes"` + usage interface{} `usage:"CF_NAME unbind-service-account APP_NAME"` + relatedCommands interface{} `related_commands:"bind-service-account, restart"` +} + +func (cmd ServiceAccountCommand) Execute(args []string) error { + if err := cmd.serviceAccountIntro("Getting service account", cmd.RequiredArgs.Name); err != nil { + return err + } + account, warnings, err := cmd.Actor.GetServiceAccountByNameAndSpace(cmd.RequiredArgs.Name, cmd.Config.TargetedSpace().GUID) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + cmd.UI.DisplayNewline() + cmd.UI.DisplayTableWithHeader("", [][]string{ + {cmd.UI.TranslateText("name:"), account.Name}, + {cmd.UI.TranslateText("guid:"), account.GUID}, + {cmd.UI.TranslateText("description:"), account.Description}, + {cmd.UI.TranslateText("enabled:"), strconv.FormatBool(account.Enabled)}, + {cmd.UI.TranslateText("status:"), account.Status}, + {cmd.UI.TranslateText("client id:"), account.ClientID}, + {cmd.UI.TranslateText("certificate DNS SAN:"), account.CertificateDNSSAN}, + }, ui.DefaultTableSpacePadding) + return nil +} +func (cmd DeleteServiceAccountCommand) Execute(args []string) error { + if err := cmd.SharedActor.CheckTarget(true, true); err != nil { + return err + } + if !cmd.Force { + confirmed, err := cmd.UI.DisplayBoolPrompt(false, "Really delete service account {{.Name}}? Its name will remain permanently reserved.", map[string]interface{}{"Name": cmd.RequiredArgs.Name}) + if err != nil { + return err + } + if !confirmed { + cmd.UI.DisplayText("Delete cancelled") + return nil + } + } + if err := cmd.serviceAccountIntro("Deleting service account", cmd.RequiredArgs.Name); err != nil { + return err + } + warnings, err := cmd.Actor.DeleteServiceAccountByNameAndSpace(cmd.RequiredArgs.Name, cmd.Config.TargetedSpace().GUID) + return cmd.serviceAccountResult(warnings, err, "The service-account name remains permanently reserved.") +} +func (cmd EnableServiceAccountCommand) Execute(args []string) error { + if err := cmd.serviceAccountIntro("Enabling service account", cmd.RequiredArgs.Name); err != nil { + return err + } + warnings, err := cmd.Actor.SetServiceAccountEnabledByNameAndSpace(cmd.RequiredArgs.Name, cmd.Config.TargetedSpace().GUID, true) + return cmd.serviceAccountResult(warnings, err, "") +} +func (cmd DisableServiceAccountCommand) Execute(args []string) error { + if err := cmd.serviceAccountIntro("Disabling service account", cmd.RequiredArgs.Name); err != nil { + return err + } + warnings, err := cmd.Actor.SetServiceAccountEnabledByNameAndSpace(cmd.RequiredArgs.Name, cmd.Config.TargetedSpace().GUID, false) + return cmd.serviceAccountResult(warnings, err, "New token issuance is disabled. Existing tokens and certificates are not revoked.") +} +func (cmd BindServiceAccountCommand) Execute(args []string) error { + if err := cmd.serviceAccountIntro("Binding service account", cmd.RequiredArgs.AccountName); err != nil { + return err + } + warnings, err := cmd.Actor.BindServiceAccountByNameAndSpace(cmd.RequiredArgs.AppName, cmd.RequiredArgs.AccountName, cmd.Config.TargetedSpace().GUID) + if err := cmd.serviceAccountResult(warnings, err, "Roles are not granted by binding."); err != nil { + return err + } + cmd.serviceAccountRestartGuidance(cmd.RequiredArgs.AppName) + return nil +} +func (cmd UnbindServiceAccountCommand) Execute(args []string) error { + if err := cmd.serviceAccountIntro("Unbinding service account from app", cmd.RequiredArgs.AppName); err != nil { + return err + } + warnings, err := cmd.Actor.UnbindServiceAccountByAppNameAndSpace(cmd.RequiredArgs.AppName, cmd.Config.TargetedSpace().GUID) + if err := cmd.serviceAccountResult(warnings, err, "Existing tokens and certificates are not revoked."); err != nil { + return err + } + cmd.serviceAccountRestartGuidance(cmd.RequiredArgs.AppName) + return nil +} + +func (cmd BaseCommand) serviceAccountIntro(action, name string) error { + if err := cmd.SharedActor.CheckTarget(true, true); err != nil { + return err + } + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + cmd.UI.DisplayTextWithFlavor("{{.Action}} {{.Name}} in org {{.Org}} / space {{.Space}} as {{.User}}...", map[string]interface{}{ + "Action": cmd.UI.TranslateText(action), "Name": name, "Org": cmd.Config.TargetedOrganization().Name, "Space": cmd.Config.TargetedSpace().Name, "User": user.Name, + }) + return nil +} + +func (cmd BaseCommand) serviceAccountResult(warnings v7action.Warnings, err error, guidance string) error { + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + cmd.UI.DisplayOK() + if guidance != "" { + cmd.UI.DisplayText(guidance) + } + return nil +} + +func (cmd BaseCommand) serviceAccountRestartGuidance(appName string) { + cmd.UI.DisplayText("Restart {{.AppName}} for the assignment change to take effect. Use '{{.Binary}} restart {{.AppName}}'.", map[string]interface{}{"AppName": appName, "Binary": cmd.Config.BinaryName()}) +} diff --git a/command/v7/service_account_lifecycle_commands_test.go b/command/v7/service_account_lifecycle_commands_test.go new file mode 100644 index 0000000000..7dea1dd424 --- /dev/null +++ b/command/v7/service_account_lifecycle_commands_test.go @@ -0,0 +1,156 @@ +package v7_test + +import ( + "errors" + "strings" + + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + . "code.cloudfoundry.org/cli/v9/command/v7" + "code.cloudfoundry.org/cli/v9/command/v7/v7fakes" + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/configv3" + "code.cloudfoundry.org/cli/v9/util/ui" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("Service Account Lifecycle Commands", func() { + var base BaseCommand + var actor *v7fakes.FakeActor + var shared *commandfakes.FakeSharedActor + var testUI *ui.UI + BeforeEach(func() { + actor = new(v7fakes.FakeActor) + shared = new(commandfakes.FakeSharedActor) + config := new(commandfakes.FakeConfig) + config.TargetedSpaceReturns(configv3.Space{GUID: "space-guid", Name: "workers"}) + config.TargetedOrganizationReturns(configv3.Organization{Name: "poc"}) + actor.GetCurrentUserReturns(configv3.User{Name: "operator"}, nil) + testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + base = BaseCommand{Actor: actor, SharedActor: shared, Config: config, UI: testUI} + }) + run := func(operation string) error { + switch operation { + case "show": + cmd := ServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.Name = "workers" + return cmd.Execute(nil) + case "delete": + cmd := DeleteServiceAccountCommand{BaseCommand: base, Force: true} + cmd.RequiredArgs.Name = "workers" + return cmd.Execute(nil) + case "enable": + cmd := EnableServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.Name = "workers" + return cmd.Execute(nil) + case "disable": + cmd := DisableServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.Name = "workers" + return cmd.Execute(nil) + case "bind": + cmd := BindServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.AppName = "app" + cmd.RequiredArgs.AccountName = "workers" + return cmd.Execute(nil) + default: + cmd := UnbindServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.AppName = "app" + return cmd.Execute(nil) + } + } + DescribeTable("performs the operation in the targeted space and reports correct consequences", func(operation string) { + actor.GetServiceAccountByNameAndSpaceReturns(resources.ServiceAccount{GUID: "account-guid", Name: "workers", Description: "Worker identity", ClientID: "cf:service-account:workers", CertificateDNSSAN: "workers.svc.identity", Enabled: true, Status: "ready"}, v7action.Warnings{"warning"}, nil) + actor.DeleteServiceAccountByNameAndSpaceReturns(v7action.Warnings{"warning"}, nil) + actor.SetServiceAccountEnabledByNameAndSpaceReturns(v7action.Warnings{"warning"}, nil) + actor.BindServiceAccountByNameAndSpaceReturns(v7action.Warnings{"warning"}, nil) + actor.UnbindServiceAccountByAppNameAndSpaceReturns(v7action.Warnings{"warning"}, nil) + Expect(run(operation)).To(Succeed()) + org, space := shared.CheckTargetArgsForCall(0) + Expect(org).To(BeTrue()) + Expect(space).To(BeTrue()) + Expect(testUI.Err).To(Say("warning")) + switch operation { + case "show": + name, guid := actor.GetServiceAccountByNameAndSpaceArgsForCall(0) + Expect(name).To(Equal("workers")) + Expect(guid).To(Equal("space-guid")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("account-guid")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Worker identity")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("cf:service-account:workers")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("workers.svc.identity")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("ready")) + case "delete": + name, guid := actor.DeleteServiceAccountByNameAndSpaceArgsForCall(0) + Expect(name).To(Equal("workers")) + Expect(guid).To(Equal("space-guid")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("permanently reserved")) + case "enable", "disable": + name, guid, enabled := actor.SetServiceAccountEnabledByNameAndSpaceArgsForCall(0) + Expect(name).To(Equal("workers")) + Expect(guid).To(Equal("space-guid")) + Expect(enabled).To(Equal(operation == "enable")) + if operation == "disable" { + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Existing tokens and certificates are not revoked")) + } + case "bind": + app, name, guid := actor.BindServiceAccountByNameAndSpaceArgsForCall(0) + Expect(app).To(Equal("app")) + Expect(name).To(Equal("workers")) + Expect(guid).To(Equal("space-guid")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Restart app")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Roles are not granted by binding")) + case "unbind": + app, guid := actor.UnbindServiceAccountByAppNameAndSpaceArgsForCall(0) + Expect(app).To(Equal("app")) + Expect(guid).To(Equal("space-guid")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Restart app")) + Expect(string(testUI.Out.(*Buffer).Contents())).To(ContainSubstring("Existing tokens and certificates are not revoked")) + Expect(actor.RestartApplicationCallCount()).To(BeZero()) + } + if operation != "show" { + Expect(testUI.Out).To(Say("OK")) + } + }, Entry("show", "show"), Entry("delete", "delete"), Entry("enable", "enable"), Entry("disable", "disable"), Entry("bind", "bind"), Entry("unbind", "unbind")) + DescribeTable("returns operation failures and warnings without success guidance", func(operation string) { + failed := errors.New("operation failed") + actor.GetServiceAccountByNameAndSpaceReturns(resources.ServiceAccount{}, v7action.Warnings{"warning"}, failed) + actor.DeleteServiceAccountByNameAndSpaceReturns(v7action.Warnings{"warning"}, failed) + actor.SetServiceAccountEnabledByNameAndSpaceReturns(v7action.Warnings{"warning"}, failed) + actor.BindServiceAccountByNameAndSpaceReturns(v7action.Warnings{"warning"}, failed) + actor.UnbindServiceAccountByAppNameAndSpaceReturns(v7action.Warnings{"warning"}, failed) + Expect(run(operation)).To(MatchError(failed)) + Expect(testUI.Err).To(Say("warning")) + Expect(testUI.Out).NotTo(Say("OK")) + Expect(testUI.Out).NotTo(Say("Restart app")) + }, Entry("show", "show"), Entry("delete", "delete"), Entry("enable", "enable"), Entry("disable", "disable"), Entry("bind", "bind"), Entry("unbind", "unbind")) + DescribeTable("stops before mutation on target failure", func(operation string) { + failed := errors.New("no target") + shared.CheckTargetReturns(failed) + Expect(run(operation)).To(MatchError(failed)) + Expect(actor.GetCurrentUserCallCount()).To(BeZero()) + Expect(actor.GetServiceAccountByNameAndSpaceCallCount() + actor.DeleteServiceAccountByNameAndSpaceCallCount() + actor.SetServiceAccountEnabledByNameAndSpaceCallCount() + actor.BindServiceAccountByNameAndSpaceCallCount() + actor.UnbindServiceAccountByAppNameAndSpaceCallCount()).To(BeZero()) + }, Entry("show", "show"), Entry("delete", "delete"), Entry("enable", "enable"), Entry("disable", "disable"), Entry("bind", "bind"), Entry("unbind", "unbind")) + It("cancels deletion by default without calling the actor", func() { + base.UI = ui.NewTestUI(strings.NewReader("n\n"), NewBuffer(), NewBuffer()) + cmd := DeleteServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.Name = "workers" + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(actor.DeleteServiceAccountByNameAndSpaceCallCount()).To(BeZero()) + Expect(base.UI.(*ui.UI).Out).To(Say("Delete cancelled")) + }) + It("confirms deletion interactively and explains retained name reservation", func() { + base.UI = ui.NewTestUI(strings.NewReader("y\n"), NewBuffer(), NewBuffer()) + cmd := DeleteServiceAccountCommand{BaseCommand: base} + cmd.RequiredArgs.Name = "workers" + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(actor.DeleteServiceAccountByNameAndSpaceCallCount()).To(Equal(1)) + Expect(base.UI.(*ui.UI).Out).To(Say("permanently reserved")) + }) + It("returns current-user failure before unbinding", func() { + actor.GetCurrentUserReturns(configv3.User{}, errors.New("user failed")) + Expect(run("unbind")).To(MatchError("user failed")) + Expect(actor.UnbindServiceAccountByAppNameAndSpaceCallCount()).To(BeZero()) + }) +}) diff --git a/command/v7/service_accounts_command.go b/command/v7/service_accounts_command.go new file mode 100644 index 0000000000..92066bcaae --- /dev/null +++ b/command/v7/service_accounts_command.go @@ -0,0 +1,42 @@ +package v7 + +import ( + "strconv" + + "code.cloudfoundry.org/cli/v9/util/ui" +) + +type ServiceAccountsCommand struct { + BaseCommand + usage interface{} `usage:"CF_NAME service-accounts"` + relatedCommands interface{} `related_commands:"create-service-account"` +} + +func (cmd ServiceAccountsCommand) Execute(args []string) error { + if err := cmd.SharedActor.CheckTarget(true, true); err != nil { + return err + } + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + cmd.UI.DisplayTextWithFlavor("Getting service accounts in org {{.Org}} / space {{.Space}} as {{.User}}...", map[string]interface{}{ + "Org": cmd.Config.TargetedOrganization().Name, "Space": cmd.Config.TargetedSpace().Name, "User": user.Name, + }) + accounts, warnings, err := cmd.Actor.GetServiceAccountsInSpace(cmd.Config.TargetedSpace().GUID) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + cmd.UI.DisplayNewline() + if len(accounts) == 0 { + cmd.UI.DisplayText("No service accounts found.") + return nil + } + table := [][]string{{cmd.UI.TranslateText("name"), cmd.UI.TranslateText("enabled"), cmd.UI.TranslateText("status"), cmd.UI.TranslateText("client id"), cmd.UI.TranslateText("certificate DNS SAN")}} + for _, account := range accounts { + table = append(table, []string{account.Name, strconv.FormatBool(account.Enabled), account.Status, account.ClientID, account.CertificateDNSSAN}) + } + cmd.UI.DisplayTableWithHeader("", table, ui.DefaultTableSpacePadding) + return nil +} diff --git a/command/v7/service_accounts_command_test.go b/command/v7/service_accounts_command_test.go new file mode 100644 index 0000000000..380f7e37c1 --- /dev/null +++ b/command/v7/service_accounts_command_test.go @@ -0,0 +1,76 @@ +package v7_test + +import ( + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + . "code.cloudfoundry.org/cli/v9/command/v7" + "code.cloudfoundry.org/cli/v9/command/v7/v7fakes" + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/configv3" + "code.cloudfoundry.org/cli/v9/util/ui" + "errors" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("service-accounts Command", func() { + var cmd ServiceAccountsCommand + var actor *v7fakes.FakeActor + var shared *commandfakes.FakeSharedActor + var testUI *ui.UI + BeforeEach(func() { + actor = new(v7fakes.FakeActor) + shared = new(commandfakes.FakeSharedActor) + config := new(commandfakes.FakeConfig) + config.TargetedSpaceReturns(configv3.Space{GUID: "space-guid", Name: "workers"}) + config.TargetedOrganizationReturns(configv3.Organization{Name: "poc"}) + actor.GetCurrentUserReturns(configv3.User{Name: "operator"}, nil) + actor.GetServiceAccountsInSpaceReturns([]resources.ServiceAccount{ + {Name: "first-account", ClientID: "cf:service-account:first-account", CertificateDNSSAN: "first-account.svc.identity", Enabled: true, Status: "ready"}, + {Name: "second-account", Enabled: false, Status: "unprovisioned"}, + }, v7action.Warnings{"list warning"}, nil) + testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + cmd = ServiceAccountsCommand{BaseCommand: BaseCommand{Actor: actor, SharedActor: shared, Config: config, UI: testUI}} + }) + It("lists the targeted space and displays identity, enabled state and provisioning status", func() { + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(shared.CheckTargetCallCount()).To(Equal(1)) + org, space := shared.CheckTargetArgsForCall(0) + Expect(org).To(BeTrue()) + Expect(space).To(BeTrue()) + Expect(actor.GetServiceAccountsInSpaceCallCount()).To(Equal(1)) + Expect(actor.GetServiceAccountsInSpaceArgsForCall(0)).To(Equal("space-guid")) + Expect(testUI.Out).To(Say("Getting service accounts in org poc / space workers as operator")) + Expect(testUI.Out).To(Say("name\\s+enabled\\s+status\\s+client id\\s+certificate DNS SAN")) + Expect(testUI.Out).To(Say("first-account\\s+true\\s+ready\\s+cf:service-account:first-account\\s+first-account.svc.identity")) + Expect(testUI.Out).To(Say("second-account\\s+false\\s+unprovisioned")) + Expect(testUI.Err).To(Say("list warning")) + }) + It("reports an empty space", func() { + actor.GetServiceAccountsInSpaceReturns(nil, nil, nil) + Expect(cmd.Execute(nil)).To(Succeed()) + Expect(testUI.Out).To(Say("No service accounts found")) + }) + It("does not query when the target is missing", func() { + missing := errors.New("no space targeted") + shared.CheckTargetReturns(missing) + Expect(cmd.Execute(nil)).To(MatchError(missing)) + Expect(actor.GetCurrentUserCallCount()).To(BeZero()) + Expect(actor.GetServiceAccountsInSpaceCallCount()).To(BeZero()) + }) + It("does not query when user resolution fails", func() { + failed := errors.New("user unavailable") + actor.GetCurrentUserReturns(configv3.User{}, failed) + Expect(cmd.Execute(nil)).To(MatchError(failed)) + Expect(actor.GetServiceAccountsInSpaceCallCount()).To(BeZero()) + }) + It("returns listing errors with warnings rather than reporting an empty space", func() { + denied := errors.New("denied") + actor.GetServiceAccountsInSpaceReturns(nil, v7action.Warnings{"denial warning"}, denied) + Expect(cmd.Execute(nil)).To(MatchError(denied)) + Expect(testUI.Err).To(Say("denial warning")) + Expect(testUI.Out).NotTo(Say("No service accounts found")) + }) +}) diff --git a/command/v7/v7fakes/fake_actor.go b/command/v7/v7fakes/fake_actor.go index c56b818c3a..e1d0eff0c6 100644 --- a/command/v7/v7fakes/fake_actor.go +++ b/command/v7/v7fakes/fake_actor.go @@ -18,19 +18,14 @@ import ( "code.cloudfoundry.org/cli/v9/resources" "code.cloudfoundry.org/cli/v9/types" "code.cloudfoundry.org/cli/v9/util/configv3" - jwtv5 "github.com/golang-jwt/jwt/v5" + jwt "github.com/golang-jwt/jwt/v5" ) type FakeActor struct { AddRoutePolicyStub func(string, string, string, string) (v7action.Warnings, error) addRoutePolicyMutex sync.RWMutex - addRoutePolicyArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - } - addRoutePolicyReturns struct { + addRoutePolicyArgsForCall []FakeActorAddRoutePolicyArgs + addRoutePolicyReturns struct { result1 v7action.Warnings result2 error } @@ -40,11 +35,8 @@ type FakeActor struct { } ApplyOrganizationQuotaByNameStub func(string, string) (v7action.Warnings, error) applyOrganizationQuotaByNameMutex sync.RWMutex - applyOrganizationQuotaByNameArgsForCall []struct { - arg1 string - arg2 string - } - applyOrganizationQuotaByNameReturns struct { + applyOrganizationQuotaByNameArgsForCall []FakeActorApplyOrganizationQuotaByNameArgs + applyOrganizationQuotaByNameReturns struct { result1 v7action.Warnings result2 error } @@ -54,12 +46,8 @@ type FakeActor struct { } ApplySpaceQuotaByNameStub func(string, string, string) (v7action.Warnings, error) applySpaceQuotaByNameMutex sync.RWMutex - applySpaceQuotaByNameArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - applySpaceQuotaByNameReturns struct { + applySpaceQuotaByNameArgsForCall []FakeActorApplySpaceQuotaByNameArgs + applySpaceQuotaByNameReturns struct { result1 v7action.Warnings result2 error } @@ -69,11 +57,8 @@ type FakeActor struct { } AssignIsolationSegmentToSpaceByNameAndSpaceStub func(string, string) (v7action.Warnings, error) assignIsolationSegmentToSpaceByNameAndSpaceMutex sync.RWMutex - assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - assignIsolationSegmentToSpaceByNameAndSpaceReturns struct { + assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall []FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs + assignIsolationSegmentToSpaceByNameAndSpaceReturns struct { result1 v7action.Warnings result2 error } @@ -83,12 +68,8 @@ type FakeActor struct { } AuthenticateStub func(map[string]string, string, constant.GrantType) error authenticateMutex sync.RWMutex - authenticateArgsForCall []struct { - arg1 map[string]string - arg2 string - arg3 constant.GrantType - } - authenticateReturns struct { + authenticateArgsForCall []FakeActorAuthenticateArgs + authenticateReturns struct { result1 error } authenticateReturnsOnCall map[int]struct { @@ -96,12 +77,8 @@ type FakeActor struct { } BindSecurityGroupToSpacesStub func(string, []resources.Space, constanta.SecurityGroupLifecycle) (v7action.Warnings, error) bindSecurityGroupToSpacesMutex sync.RWMutex - bindSecurityGroupToSpacesArgsForCall []struct { - arg1 string - arg2 []resources.Space - arg3 constanta.SecurityGroupLifecycle - } - bindSecurityGroupToSpacesReturns struct { + bindSecurityGroupToSpacesArgsForCall []FakeActorBindSecurityGroupToSpacesArgs + bindSecurityGroupToSpacesReturns struct { result1 v7action.Warnings result2 error } @@ -109,12 +86,21 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + BindServiceAccountByNameAndSpaceStub func(string, string, string) (v7action.Warnings, error) + bindServiceAccountByNameAndSpaceMutex sync.RWMutex + bindServiceAccountByNameAndSpaceArgsForCall []FakeActorBindServiceAccountByNameAndSpaceArgs + bindServiceAccountByNameAndSpaceReturns struct { + result1 v7action.Warnings + result2 error + } + bindServiceAccountByNameAndSpaceReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } CancelDeploymentStub func(string) (v7action.Warnings, error) cancelDeploymentMutex sync.RWMutex - cancelDeploymentArgsForCall []struct { - arg1 string - } - cancelDeploymentReturns struct { + cancelDeploymentArgsForCall []FakeActorCancelDeploymentArgs + cancelDeploymentReturns struct { result1 v7action.Warnings result2 error } @@ -124,13 +110,8 @@ type FakeActor struct { } CheckRouteStub func(string, string, string, int) (bool, v7action.Warnings, error) checkRouteMutex sync.RWMutex - checkRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - checkRouteReturns struct { + checkRouteArgsForCall []FakeActorCheckRouteArgs + checkRouteReturns struct { result1 bool result2 v7action.Warnings result3 error @@ -140,16 +121,13 @@ type FakeActor struct { result2 v7action.Warnings result3 error } - ClearTargetStub func() - clearTargetMutex sync.RWMutex - clearTargetArgsForCall []struct { - } + ClearTargetStub func() + clearTargetMutex sync.RWMutex + clearTargetArgsForCall []struct{} ContinueDeploymentStub func(string) (v7action.Warnings, error) continueDeploymentMutex sync.RWMutex - continueDeploymentArgsForCall []struct { - arg1 string - } - continueDeploymentReturns struct { + continueDeploymentArgsForCall []FakeActorContinueDeploymentArgs + continueDeploymentReturns struct { result1 v7action.Warnings result2 error } @@ -159,11 +137,8 @@ type FakeActor struct { } CopyPackageStub func(resources.Application, resources.Application) (resources.Package, v7action.Warnings, error) copyPackageMutex sync.RWMutex - copyPackageArgsForCall []struct { - arg1 resources.Application - arg2 resources.Application - } - copyPackageReturns struct { + copyPackageArgsForCall []FakeActorCopyPackageArgs + copyPackageReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -175,12 +150,8 @@ type FakeActor struct { } CreateAndUploadBitsPackageByApplicationNameAndSpaceStub func(string, string, string) (resources.Package, v7action.Warnings, error) createAndUploadBitsPackageByApplicationNameAndSpaceMutex sync.RWMutex - createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - createAndUploadBitsPackageByApplicationNameAndSpaceReturns struct { + createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall []FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs + createAndUploadBitsPackageByApplicationNameAndSpaceReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -192,10 +163,8 @@ type FakeActor struct { } CreateApplicationDropletStub func(string) (resources.Droplet, v7action.Warnings, error) createApplicationDropletMutex sync.RWMutex - createApplicationDropletArgsForCall []struct { - arg1 string - } - createApplicationDropletReturns struct { + createApplicationDropletArgsForCall []FakeActorCreateApplicationDropletArgs + createApplicationDropletReturns struct { result1 resources.Droplet result2 v7action.Warnings result3 error @@ -207,11 +176,8 @@ type FakeActor struct { } CreateApplicationInSpaceStub func(resources.Application, string) (resources.Application, v7action.Warnings, error) createApplicationInSpaceMutex sync.RWMutex - createApplicationInSpaceArgsForCall []struct { - arg1 resources.Application - arg2 string - } - createApplicationInSpaceReturns struct { + createApplicationInSpaceArgsForCall []FakeActorCreateApplicationInSpaceArgs + createApplicationInSpaceReturns struct { result1 resources.Application result2 v7action.Warnings result3 error @@ -223,10 +189,8 @@ type FakeActor struct { } CreateBitsPackageByApplicationStub func(string) (resources.Package, v7action.Warnings, error) createBitsPackageByApplicationMutex sync.RWMutex - createBitsPackageByApplicationArgsForCall []struct { - arg1 string - } - createBitsPackageByApplicationReturns struct { + createBitsPackageByApplicationArgsForCall []FakeActorCreateBitsPackageByApplicationArgs + createBitsPackageByApplicationReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -238,10 +202,8 @@ type FakeActor struct { } CreateBuildpackStub func(resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) createBuildpackMutex sync.RWMutex - createBuildpackArgsForCall []struct { - arg1 resources.Buildpack - } - createBuildpackReturns struct { + createBuildpackArgsForCall []FakeActorCreateBuildpackArgs + createBuildpackReturns struct { result1 resources.Buildpack result2 v7action.Warnings result3 error @@ -253,10 +215,8 @@ type FakeActor struct { } CreateDeploymentStub func(resources.Deployment) (string, v7action.Warnings, error) createDeploymentMutex sync.RWMutex - createDeploymentArgsForCall []struct { - arg1 resources.Deployment - } - createDeploymentReturns struct { + createDeploymentArgsForCall []FakeActorCreateDeploymentArgs + createDeploymentReturns struct { result1 string result2 v7action.Warnings result3 error @@ -268,11 +228,8 @@ type FakeActor struct { } CreateDockerPackageByApplicationStub func(string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) createDockerPackageByApplicationMutex sync.RWMutex - createDockerPackageByApplicationArgsForCall []struct { - arg1 string - arg2 v7action.DockerImageCredentials - } - createDockerPackageByApplicationReturns struct { + createDockerPackageByApplicationArgsForCall []FakeActorCreateDockerPackageByApplicationArgs + createDockerPackageByApplicationReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -284,12 +241,8 @@ type FakeActor struct { } CreateDockerPackageByApplicationNameAndSpaceStub func(string, string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) createDockerPackageByApplicationNameAndSpaceMutex sync.RWMutex - createDockerPackageByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.DockerImageCredentials - } - createDockerPackageByApplicationNameAndSpaceReturns struct { + createDockerPackageByApplicationNameAndSpaceArgsForCall []FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs + createDockerPackageByApplicationNameAndSpaceReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -301,10 +254,8 @@ type FakeActor struct { } CreateIsolationSegmentByNameStub func(resources.IsolationSegment) (v7action.Warnings, error) createIsolationSegmentByNameMutex sync.RWMutex - createIsolationSegmentByNameArgsForCall []struct { - arg1 resources.IsolationSegment - } - createIsolationSegmentByNameReturns struct { + createIsolationSegmentByNameArgsForCall []FakeActorCreateIsolationSegmentByNameArgs + createIsolationSegmentByNameReturns struct { result1 v7action.Warnings result2 error } @@ -314,10 +265,8 @@ type FakeActor struct { } CreateManagedServiceInstanceStub func(v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) createManagedServiceInstanceMutex sync.RWMutex - createManagedServiceInstanceArgsForCall []struct { - arg1 v7action.CreateManagedServiceInstanceParams - } - createManagedServiceInstanceReturns struct { + createManagedServiceInstanceArgsForCall []FakeActorCreateManagedServiceInstanceArgs + createManagedServiceInstanceReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -329,14 +278,8 @@ type FakeActor struct { } CreateOrgRoleStub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error) createOrgRoleMutex sync.RWMutex - createOrgRoleArgsForCall []struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - } - createOrgRoleReturns struct { + createOrgRoleArgsForCall []FakeActorCreateOrgRoleArgs + createOrgRoleReturns struct { result1 v7action.Warnings result2 error } @@ -346,10 +289,8 @@ type FakeActor struct { } CreateOrganizationStub func(string) (resources.Organization, v7action.Warnings, error) createOrganizationMutex sync.RWMutex - createOrganizationArgsForCall []struct { - arg1 string - } - createOrganizationReturns struct { + createOrganizationArgsForCall []FakeActorCreateOrganizationArgs + createOrganizationReturns struct { result1 resources.Organization result2 v7action.Warnings result3 error @@ -361,11 +302,8 @@ type FakeActor struct { } CreateOrganizationQuotaStub func(string, v7action.QuotaLimits) (v7action.Warnings, error) createOrganizationQuotaMutex sync.RWMutex - createOrganizationQuotaArgsForCall []struct { - arg1 string - arg2 v7action.QuotaLimits - } - createOrganizationQuotaReturns struct { + createOrganizationQuotaArgsForCall []FakeActorCreateOrganizationQuotaArgs + createOrganizationQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -375,13 +313,8 @@ type FakeActor struct { } CreatePrivateDomainStub func(string, string, bool, string) (v7action.Warnings, error) createPrivateDomainMutex sync.RWMutex - createPrivateDomainArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - arg4 string - } - createPrivateDomainReturns struct { + createPrivateDomainArgsForCall []FakeActorCreatePrivateDomainArgs + createPrivateDomainReturns struct { result1 v7action.Warnings result2 error } @@ -391,15 +324,8 @@ type FakeActor struct { } CreateRouteStub func(string, string, string, string, int, map[string]*string) (resources.Route, v7action.Warnings, error) createRouteMutex sync.RWMutex - createRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - arg5 int - arg6 map[string]*string - } - createRouteReturns struct { + createRouteArgsForCall []FakeActorCreateRouteArgs + createRouteReturns struct { result1 resources.Route result2 v7action.Warnings result3 error @@ -411,10 +337,8 @@ type FakeActor struct { } CreateRouteBindingStub func(v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) createRouteBindingMutex sync.RWMutex - createRouteBindingArgsForCall []struct { - arg1 v7action.CreateRouteBindingParams - } - createRouteBindingReturns struct { + createRouteBindingArgsForCall []FakeActorCreateRouteBindingArgs + createRouteBindingReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -426,11 +350,8 @@ type FakeActor struct { } CreateSecurityGroupStub func(string, string) (v7action.Warnings, error) createSecurityGroupMutex sync.RWMutex - createSecurityGroupArgsForCall []struct { - arg1 string - arg2 string - } - createSecurityGroupReturns struct { + createSecurityGroupArgsForCall []FakeActorCreateSecurityGroupArgs + createSecurityGroupReturns struct { result1 v7action.Warnings result2 error } @@ -438,12 +359,23 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + CreateServiceAccountInSpaceStub func(string, string, string) (resources.ServiceAccount, v7action.Warnings, error) + createServiceAccountInSpaceMutex sync.RWMutex + createServiceAccountInSpaceArgsForCall []FakeActorCreateServiceAccountInSpaceArgs + createServiceAccountInSpaceReturns struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + } + createServiceAccountInSpaceReturnsOnCall map[int]struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + } CreateServiceAppBindingStub func(v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) createServiceAppBindingMutex sync.RWMutex - createServiceAppBindingArgsForCall []struct { - arg1 v7action.CreateServiceAppBindingParams - } - createServiceAppBindingReturns struct { + createServiceAppBindingArgsForCall []FakeActorCreateServiceAppBindingArgs + createServiceAppBindingReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -455,10 +387,8 @@ type FakeActor struct { } CreateServiceBrokerStub func(resources.ServiceBroker) (v7action.Warnings, error) createServiceBrokerMutex sync.RWMutex - createServiceBrokerArgsForCall []struct { - arg1 resources.ServiceBroker - } - createServiceBrokerReturns struct { + createServiceBrokerArgsForCall []FakeActorCreateServiceBrokerArgs + createServiceBrokerReturns struct { result1 v7action.Warnings result2 error } @@ -468,10 +398,8 @@ type FakeActor struct { } CreateServiceKeyStub func(v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error) createServiceKeyMutex sync.RWMutex - createServiceKeyArgsForCall []struct { - arg1 v7action.CreateServiceKeyParams - } - createServiceKeyReturns struct { + createServiceKeyArgsForCall []FakeActorCreateServiceKeyArgs + createServiceKeyReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -483,14 +411,8 @@ type FakeActor struct { } CreateSharedDomainStub func(string, bool, string, bool, string) (v7action.Warnings, error) createSharedDomainMutex sync.RWMutex - createSharedDomainArgsForCall []struct { - arg1 string - arg2 bool - arg3 string - arg4 bool - arg5 string - } - createSharedDomainReturns struct { + createSharedDomainArgsForCall []FakeActorCreateSharedDomainArgs + createSharedDomainReturns struct { result1 v7action.Warnings result2 error } @@ -500,11 +422,8 @@ type FakeActor struct { } CreateSpaceStub func(string, string) (resources.Space, v7action.Warnings, error) createSpaceMutex sync.RWMutex - createSpaceArgsForCall []struct { - arg1 string - arg2 string - } - createSpaceReturns struct { + createSpaceArgsForCall []FakeActorCreateSpaceArgs + createSpaceReturns struct { result1 resources.Space result2 v7action.Warnings result3 error @@ -516,12 +435,8 @@ type FakeActor struct { } CreateSpaceQuotaStub func(string, string, v7action.QuotaLimits) (v7action.Warnings, error) createSpaceQuotaMutex sync.RWMutex - createSpaceQuotaArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.QuotaLimits - } - createSpaceQuotaReturns struct { + createSpaceQuotaArgsForCall []FakeActorCreateSpaceQuotaArgs + createSpaceQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -531,15 +446,8 @@ type FakeActor struct { } CreateSpaceRoleStub func(constanta.RoleType, string, string, string, string, bool) (v7action.Warnings, error) createSpaceRoleMutex sync.RWMutex - createSpaceRoleArgsForCall []struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 string - arg6 bool - } - createSpaceRoleReturns struct { + createSpaceRoleArgsForCall []FakeActorCreateSpaceRoleArgs + createSpaceRoleReturns struct { result1 v7action.Warnings result2 error } @@ -549,12 +457,8 @@ type FakeActor struct { } CreateUserStub func(string, string, string) (resources.User, v7action.Warnings, error) createUserMutex sync.RWMutex - createUserArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - createUserReturns struct { + createUserArgsForCall []FakeActorCreateUserArgs + createUserReturns struct { result1 resources.User result2 v7action.Warnings result3 error @@ -566,10 +470,8 @@ type FakeActor struct { } CreateUserProvidedServiceInstanceStub func(resources.ServiceInstance) (v7action.Warnings, error) createUserProvidedServiceInstanceMutex sync.RWMutex - createUserProvidedServiceInstanceArgsForCall []struct { - arg1 resources.ServiceInstance - } - createUserProvidedServiceInstanceReturns struct { + createUserProvidedServiceInstanceArgsForCall []FakeActorCreateUserProvidedServiceInstanceArgs + createUserProvidedServiceInstanceReturns struct { result1 v7action.Warnings result2 error } @@ -579,12 +481,8 @@ type FakeActor struct { } DeleteApplicationByNameAndSpaceStub func(string, string, bool) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteApplicationByNameAndSpaceMutex sync.RWMutex - deleteApplicationByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - } - deleteApplicationByNameAndSpaceReturns struct { + deleteApplicationByNameAndSpaceArgsForCall []FakeActorDeleteApplicationByNameAndSpaceArgs + deleteApplicationByNameAndSpaceReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -596,12 +494,8 @@ type FakeActor struct { } DeleteBuildpackByNameAndStackAndLifecycleStub func(string, string, string) (v7action.Warnings, error) deleteBuildpackByNameAndStackAndLifecycleMutex sync.RWMutex - deleteBuildpackByNameAndStackAndLifecycleArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - deleteBuildpackByNameAndStackAndLifecycleReturns struct { + deleteBuildpackByNameAndStackAndLifecycleArgsForCall []FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs + deleteBuildpackByNameAndStackAndLifecycleReturns struct { result1 v7action.Warnings result2 error } @@ -611,10 +505,8 @@ type FakeActor struct { } DeleteDomainStub func(resources.Domain) (v7action.Warnings, error) deleteDomainMutex sync.RWMutex - deleteDomainArgsForCall []struct { - arg1 resources.Domain - } - deleteDomainReturns struct { + deleteDomainArgsForCall []FakeActorDeleteDomainArgs + deleteDomainReturns struct { result1 v7action.Warnings result2 error } @@ -624,13 +516,8 @@ type FakeActor struct { } DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub func(string, string, string, int) (v7action.Warnings, error) deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex sync.RWMutex - deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns struct { + deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall []FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs + deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns struct { result1 v7action.Warnings result2 error } @@ -640,10 +527,8 @@ type FakeActor struct { } DeleteIsolationSegmentByNameStub func(string) (v7action.Warnings, error) deleteIsolationSegmentByNameMutex sync.RWMutex - deleteIsolationSegmentByNameArgsForCall []struct { - arg1 string - } - deleteIsolationSegmentByNameReturns struct { + deleteIsolationSegmentByNameArgsForCall []FakeActorDeleteIsolationSegmentByNameArgs + deleteIsolationSegmentByNameReturns struct { result1 v7action.Warnings result2 error } @@ -653,11 +538,8 @@ type FakeActor struct { } DeleteIsolationSegmentOrganizationByNameStub func(string, string) (v7action.Warnings, error) deleteIsolationSegmentOrganizationByNameMutex sync.RWMutex - deleteIsolationSegmentOrganizationByNameArgsForCall []struct { - arg1 string - arg2 string - } - deleteIsolationSegmentOrganizationByNameReturns struct { + deleteIsolationSegmentOrganizationByNameArgsForCall []FakeActorDeleteIsolationSegmentOrganizationByNameArgs + deleteIsolationSegmentOrganizationByNameReturns struct { result1 v7action.Warnings result2 error } @@ -667,14 +549,8 @@ type FakeActor struct { } DeleteOrgRoleStub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error) deleteOrgRoleMutex sync.RWMutex - deleteOrgRoleArgsForCall []struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - } - deleteOrgRoleReturns struct { + deleteOrgRoleArgsForCall []FakeActorDeleteOrgRoleArgs + deleteOrgRoleReturns struct { result1 v7action.Warnings result2 error } @@ -684,10 +560,8 @@ type FakeActor struct { } DeleteOrganizationStub func(string) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteOrganizationMutex sync.RWMutex - deleteOrganizationArgsForCall []struct { - arg1 string - } - deleteOrganizationReturns struct { + deleteOrganizationArgsForCall []FakeActorDeleteOrganizationArgs + deleteOrganizationReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -699,10 +573,8 @@ type FakeActor struct { } DeleteOrganizationQuotaStub func(string) (v7action.Warnings, error) deleteOrganizationQuotaMutex sync.RWMutex - deleteOrganizationQuotaArgsForCall []struct { - arg1 string - } - deleteOrganizationQuotaReturns struct { + deleteOrganizationQuotaArgsForCall []FakeActorDeleteOrganizationQuotaArgs + deleteOrganizationQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -712,10 +584,8 @@ type FakeActor struct { } DeleteOrphanedRoutesStub func(string) (v7action.Warnings, error) deleteOrphanedRoutesMutex sync.RWMutex - deleteOrphanedRoutesArgsForCall []struct { - arg1 string - } - deleteOrphanedRoutesReturns struct { + deleteOrphanedRoutesArgsForCall []FakeActorDeleteOrphanedRoutesArgs + deleteOrphanedRoutesReturns struct { result1 v7action.Warnings result2 error } @@ -725,13 +595,8 @@ type FakeActor struct { } DeleteRouteStub func(string, string, string, int) (v7action.Warnings, error) deleteRouteMutex sync.RWMutex - deleteRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - deleteRouteReturns struct { + deleteRouteArgsForCall []FakeActorDeleteRouteArgs + deleteRouteReturns struct { result1 v7action.Warnings result2 error } @@ -741,10 +606,8 @@ type FakeActor struct { } DeleteRouteBindingStub func(v7action.DeleteRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteRouteBindingMutex sync.RWMutex - deleteRouteBindingArgsForCall []struct { - arg1 v7action.DeleteRouteBindingParams - } - deleteRouteBindingReturns struct { + deleteRouteBindingArgsForCall []FakeActorDeleteRouteBindingArgs + deleteRouteBindingReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -756,13 +619,8 @@ type FakeActor struct { } DeleteRoutePolicyBySourceStub func(string, string, string, string) (v7action.Warnings, error) deleteRoutePolicyBySourceMutex sync.RWMutex - deleteRoutePolicyBySourceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - } - deleteRoutePolicyBySourceReturns struct { + deleteRoutePolicyBySourceArgsForCall []FakeActorDeleteRoutePolicyBySourceArgs + deleteRoutePolicyBySourceReturns struct { result1 v7action.Warnings result2 error } @@ -772,10 +630,8 @@ type FakeActor struct { } DeleteSecurityGroupStub func(string) (v7action.Warnings, error) deleteSecurityGroupMutex sync.RWMutex - deleteSecurityGroupArgsForCall []struct { - arg1 string - } - deleteSecurityGroupReturns struct { + deleteSecurityGroupArgsForCall []FakeActorDeleteSecurityGroupArgs + deleteSecurityGroupReturns struct { result1 v7action.Warnings result2 error } @@ -783,12 +639,21 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + DeleteServiceAccountByNameAndSpaceStub func(string, string) (v7action.Warnings, error) + deleteServiceAccountByNameAndSpaceMutex sync.RWMutex + deleteServiceAccountByNameAndSpaceArgsForCall []FakeActorDeleteServiceAccountByNameAndSpaceArgs + deleteServiceAccountByNameAndSpaceReturns struct { + result1 v7action.Warnings + result2 error + } + deleteServiceAccountByNameAndSpaceReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } DeleteServiceAppBindingStub func(v7action.DeleteServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteServiceAppBindingMutex sync.RWMutex - deleteServiceAppBindingArgsForCall []struct { - arg1 v7action.DeleteServiceAppBindingParams - } - deleteServiceAppBindingReturns struct { + deleteServiceAppBindingArgsForCall []FakeActorDeleteServiceAppBindingArgs + deleteServiceAppBindingReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -800,10 +665,8 @@ type FakeActor struct { } DeleteServiceBrokerStub func(string) (v7action.Warnings, error) deleteServiceBrokerMutex sync.RWMutex - deleteServiceBrokerArgsForCall []struct { - arg1 string - } - deleteServiceBrokerReturns struct { + deleteServiceBrokerArgsForCall []FakeActorDeleteServiceBrokerArgs + deleteServiceBrokerReturns struct { result1 v7action.Warnings result2 error } @@ -813,11 +676,8 @@ type FakeActor struct { } DeleteServiceInstanceStub func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteServiceInstanceMutex sync.RWMutex - deleteServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - } - deleteServiceInstanceReturns struct { + deleteServiceInstanceArgsForCall []FakeActorDeleteServiceInstanceArgs + deleteServiceInstanceReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -829,12 +689,8 @@ type FakeActor struct { } DeleteServiceKeyByServiceInstanceAndNameStub func(string, string, string) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteServiceKeyByServiceInstanceAndNameMutex sync.RWMutex - deleteServiceKeyByServiceInstanceAndNameArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - deleteServiceKeyByServiceInstanceAndNameReturns struct { + deleteServiceKeyByServiceInstanceAndNameArgsForCall []FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs + deleteServiceKeyByServiceInstanceAndNameReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -846,11 +702,8 @@ type FakeActor struct { } DeleteSpaceByNameAndOrganizationNameStub func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error) deleteSpaceByNameAndOrganizationNameMutex sync.RWMutex - deleteSpaceByNameAndOrganizationNameArgsForCall []struct { - arg1 string - arg2 string - } - deleteSpaceByNameAndOrganizationNameReturns struct { + deleteSpaceByNameAndOrganizationNameArgsForCall []FakeActorDeleteSpaceByNameAndOrganizationNameArgs + deleteSpaceByNameAndOrganizationNameReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -862,11 +715,8 @@ type FakeActor struct { } DeleteSpaceQuotaByNameStub func(string, string) (v7action.Warnings, error) deleteSpaceQuotaByNameMutex sync.RWMutex - deleteSpaceQuotaByNameArgsForCall []struct { - arg1 string - arg2 string - } - deleteSpaceQuotaByNameReturns struct { + deleteSpaceQuotaByNameArgsForCall []FakeActorDeleteSpaceQuotaByNameArgs + deleteSpaceQuotaByNameReturns struct { result1 v7action.Warnings result2 error } @@ -876,14 +726,8 @@ type FakeActor struct { } DeleteSpaceRoleStub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error) deleteSpaceRoleMutex sync.RWMutex - deleteSpaceRoleArgsForCall []struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - } - deleteSpaceRoleReturns struct { + deleteSpaceRoleArgsForCall []FakeActorDeleteSpaceRoleArgs + deleteSpaceRoleReturns struct { result1 v7action.Warnings result2 error } @@ -893,10 +737,8 @@ type FakeActor struct { } DeleteUserStub func(string) (v7action.Warnings, error) deleteUserMutex sync.RWMutex - deleteUserArgsForCall []struct { - arg1 string - } - deleteUserReturns struct { + deleteUserArgsForCall []FakeActorDeleteUserArgs + deleteUserReturns struct { result1 v7action.Warnings result2 error } @@ -906,11 +748,8 @@ type FakeActor struct { } DiffSpaceManifestStub func(string, []byte) (resources.ManifestDiff, v7action.Warnings, error) diffSpaceManifestMutex sync.RWMutex - diffSpaceManifestArgsForCall []struct { - arg1 string - arg2 []byte - } - diffSpaceManifestReturns struct { + diffSpaceManifestArgsForCall []FakeActorDiffSpaceManifestArgs + diffSpaceManifestReturns struct { result1 resources.ManifestDiff result2 v7action.Warnings result3 error @@ -922,10 +761,8 @@ type FakeActor struct { } DisableFeatureFlagStub func(string) (v7action.Warnings, error) disableFeatureFlagMutex sync.RWMutex - disableFeatureFlagArgsForCall []struct { - arg1 string - } - disableFeatureFlagReturns struct { + disableFeatureFlagArgsForCall []FakeActorDisableFeatureFlagArgs + disableFeatureFlagReturns struct { result1 v7action.Warnings result2 error } @@ -935,13 +772,8 @@ type FakeActor struct { } DisableServiceAccessStub func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error) disableServiceAccessMutex sync.RWMutex - disableServiceAccessArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - } - disableServiceAccessReturns struct { + disableServiceAccessArgsForCall []FakeActorDisableServiceAccessArgs + disableServiceAccessReturns struct { result1 v7action.SkippedPlans result2 v7action.Warnings result3 error @@ -953,11 +785,8 @@ type FakeActor struct { } DownloadCurrentDropletByAppNameStub func(string, string) ([]byte, string, v7action.Warnings, error) downloadCurrentDropletByAppNameMutex sync.RWMutex - downloadCurrentDropletByAppNameArgsForCall []struct { - arg1 string - arg2 string - } - downloadCurrentDropletByAppNameReturns struct { + downloadCurrentDropletByAppNameArgsForCall []FakeActorDownloadCurrentDropletByAppNameArgs + downloadCurrentDropletByAppNameReturns struct { result1 []byte result2 string result3 v7action.Warnings @@ -971,12 +800,8 @@ type FakeActor struct { } DownloadDropletByGUIDAndAppNameStub func(string, string, string) ([]byte, v7action.Warnings, error) downloadDropletByGUIDAndAppNameMutex sync.RWMutex - downloadDropletByGUIDAndAppNameArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - downloadDropletByGUIDAndAppNameReturns struct { + downloadDropletByGUIDAndAppNameArgsForCall []FakeActorDownloadDropletByGUIDAndAppNameArgs + downloadDropletByGUIDAndAppNameReturns struct { result1 []byte result2 v7action.Warnings result3 error @@ -988,10 +813,8 @@ type FakeActor struct { } EnableFeatureFlagStub func(string) (v7action.Warnings, error) enableFeatureFlagMutex sync.RWMutex - enableFeatureFlagArgsForCall []struct { - arg1 string - } - enableFeatureFlagReturns struct { + enableFeatureFlagArgsForCall []FakeActorEnableFeatureFlagArgs + enableFeatureFlagReturns struct { result1 v7action.Warnings result2 error } @@ -1001,13 +824,8 @@ type FakeActor struct { } EnableServiceAccessStub func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error) enableServiceAccessMutex sync.RWMutex - enableServiceAccessArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - } - enableServiceAccessReturns struct { + enableServiceAccessArgsForCall []FakeActorEnableServiceAccessArgs + enableServiceAccessReturns struct { result1 v7action.SkippedPlans result2 v7action.Warnings result3 error @@ -1019,11 +837,8 @@ type FakeActor struct { } EntitleIsolationSegmentToOrganizationByNameStub func(string, string) (v7action.Warnings, error) entitleIsolationSegmentToOrganizationByNameMutex sync.RWMutex - entitleIsolationSegmentToOrganizationByNameArgsForCall []struct { - arg1 string - arg2 string - } - entitleIsolationSegmentToOrganizationByNameReturns struct { + entitleIsolationSegmentToOrganizationByNameArgsForCall []FakeActorEntitleIsolationSegmentToOrganizationByNameArgs + entitleIsolationSegmentToOrganizationByNameReturns struct { result1 v7action.Warnings result2 error } @@ -1033,11 +848,8 @@ type FakeActor struct { } GetAppFeatureStub func(string, string) (resources.ApplicationFeature, v7action.Warnings, error) getAppFeatureMutex sync.RWMutex - getAppFeatureArgsForCall []struct { - arg1 string - arg2 string - } - getAppFeatureReturns struct { + getAppFeatureArgsForCall []FakeActorGetAppFeatureArgs + getAppFeatureReturns struct { result1 resources.ApplicationFeature result2 v7action.Warnings result3 error @@ -1049,12 +861,8 @@ type FakeActor struct { } GetAppSummariesForSpaceStub func(string, string, bool) ([]v7action.ApplicationSummary, v7action.Warnings, error) getAppSummariesForSpaceMutex sync.RWMutex - getAppSummariesForSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - } - getAppSummariesForSpaceReturns struct { + getAppSummariesForSpaceArgsForCall []FakeActorGetAppSummariesForSpaceArgs + getAppSummariesForSpaceReturns struct { result1 []v7action.ApplicationSummary result2 v7action.Warnings result3 error @@ -1066,11 +874,8 @@ type FakeActor struct { } GetApplicationByNameAndSpaceStub func(string, string) (resources.Application, v7action.Warnings, error) getApplicationByNameAndSpaceMutex sync.RWMutex - getApplicationByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationByNameAndSpaceReturns struct { + getApplicationByNameAndSpaceArgsForCall []FakeActorGetApplicationByNameAndSpaceArgs + getApplicationByNameAndSpaceReturns struct { result1 resources.Application result2 v7action.Warnings result3 error @@ -1082,11 +887,8 @@ type FakeActor struct { } GetApplicationDropletsStub func(string, string) ([]resources.Droplet, v7action.Warnings, error) getApplicationDropletsMutex sync.RWMutex - getApplicationDropletsArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationDropletsReturns struct { + getApplicationDropletsArgsForCall []FakeActorGetApplicationDropletsArgs + getApplicationDropletsReturns struct { result1 []resources.Droplet result2 v7action.Warnings result3 error @@ -1098,11 +900,8 @@ type FakeActor struct { } GetApplicationLabelsStub func(string, string) (map[string]types.NullString, v7action.Warnings, error) getApplicationLabelsMutex sync.RWMutex - getApplicationLabelsArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationLabelsReturns struct { + getApplicationLabelsArgsForCall []FakeActorGetApplicationLabelsArgs + getApplicationLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1114,10 +913,8 @@ type FakeActor struct { } GetApplicationMapForRouteStub func(resources.Route) (map[string]resources.Application, v7action.Warnings, error) getApplicationMapForRouteMutex sync.RWMutex - getApplicationMapForRouteArgsForCall []struct { - arg1 resources.Route - } - getApplicationMapForRouteReturns struct { + getApplicationMapForRouteArgsForCall []FakeActorGetApplicationMapForRouteArgs + getApplicationMapForRouteReturns struct { result1 map[string]resources.Application result2 v7action.Warnings result3 error @@ -1129,11 +926,8 @@ type FakeActor struct { } GetApplicationPackagesStub func(string, string) ([]resources.Package, v7action.Warnings, error) getApplicationPackagesMutex sync.RWMutex - getApplicationPackagesArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationPackagesReturns struct { + getApplicationPackagesArgsForCall []FakeActorGetApplicationPackagesArgs + getApplicationPackagesReturns struct { result1 []resources.Package result2 v7action.Warnings result3 error @@ -1145,11 +939,8 @@ type FakeActor struct { } GetApplicationProcessHealthChecksByNameAndSpaceStub func(string, string) ([]v7action.ProcessHealthCheck, v7action.Warnings, error) getApplicationProcessHealthChecksByNameAndSpaceMutex sync.RWMutex - getApplicationProcessHealthChecksByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationProcessHealthChecksByNameAndSpaceReturns struct { + getApplicationProcessHealthChecksByNameAndSpaceArgsForCall []FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs + getApplicationProcessHealthChecksByNameAndSpaceReturns struct { result1 []v7action.ProcessHealthCheck result2 v7action.Warnings result3 error @@ -1161,11 +952,8 @@ type FakeActor struct { } GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub func(string, string) ([]v7action.ProcessReadinessHealthCheck, v7action.Warnings, error) getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex sync.RWMutex - getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns struct { + getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall []FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs + getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns struct { result1 []v7action.ProcessReadinessHealthCheck result2 v7action.Warnings result3 error @@ -1177,10 +965,8 @@ type FakeActor struct { } GetApplicationRevisionsDeployedStub func(string) ([]resources.Revision, v7action.Warnings, error) getApplicationRevisionsDeployedMutex sync.RWMutex - getApplicationRevisionsDeployedArgsForCall []struct { - arg1 string - } - getApplicationRevisionsDeployedReturns struct { + getApplicationRevisionsDeployedArgsForCall []FakeActorGetApplicationRevisionsDeployedArgs + getApplicationRevisionsDeployedReturns struct { result1 []resources.Revision result2 v7action.Warnings result3 error @@ -1192,10 +978,8 @@ type FakeActor struct { } GetApplicationRoutesStub func(string) ([]resources.Route, v7action.Warnings, error) getApplicationRoutesMutex sync.RWMutex - getApplicationRoutesArgsForCall []struct { - arg1 string - } - getApplicationRoutesReturns struct { + getApplicationRoutesArgsForCall []FakeActorGetApplicationRoutesArgs + getApplicationRoutesReturns struct { result1 []resources.Route result2 v7action.Warnings result3 error @@ -1207,11 +991,8 @@ type FakeActor struct { } GetApplicationTasksStub func(string, v7action.SortOrder) ([]resources.Task, v7action.Warnings, error) getApplicationTasksMutex sync.RWMutex - getApplicationTasksArgsForCall []struct { - arg1 string - arg2 v7action.SortOrder - } - getApplicationTasksReturns struct { + getApplicationTasksArgsForCall []FakeActorGetApplicationTasksArgs + getApplicationTasksReturns struct { result1 []resources.Task result2 v7action.Warnings result3 error @@ -1223,10 +1004,8 @@ type FakeActor struct { } GetApplicationsByGUIDsStub func([]string) ([]resources.Application, v7action.Warnings, error) getApplicationsByGUIDsMutex sync.RWMutex - getApplicationsByGUIDsArgsForCall []struct { - arg1 []string - } - getApplicationsByGUIDsReturns struct { + getApplicationsByGUIDsArgsForCall []FakeActorGetApplicationsByGUIDsArgs + getApplicationsByGUIDsReturns struct { result1 []resources.Application result2 v7action.Warnings result3 error @@ -1238,11 +1017,8 @@ type FakeActor struct { } GetApplicationsByNamesAndSpaceStub func([]string, string) ([]resources.Application, v7action.Warnings, error) getApplicationsByNamesAndSpaceMutex sync.RWMutex - getApplicationsByNamesAndSpaceArgsForCall []struct { - arg1 []string - arg2 string - } - getApplicationsByNamesAndSpaceReturns struct { + getApplicationsByNamesAndSpaceArgsForCall []FakeActorGetApplicationsByNamesAndSpaceArgs + getApplicationsByNamesAndSpaceReturns struct { result1 []resources.Application result2 v7action.Warnings result3 error @@ -1254,12 +1030,8 @@ type FakeActor struct { } GetBuildpackLabelsStub func(string, string, string) (map[string]types.NullString, v7action.Warnings, error) getBuildpackLabelsMutex sync.RWMutex - getBuildpackLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getBuildpackLabelsReturns struct { + getBuildpackLabelsArgsForCall []FakeActorGetBuildpackLabelsArgs + getBuildpackLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1271,11 +1043,8 @@ type FakeActor struct { } GetBuildpacksStub func(string, string) ([]resources.Buildpack, v7action.Warnings, error) getBuildpacksMutex sync.RWMutex - getBuildpacksArgsForCall []struct { - arg1 string - arg2 string - } - getBuildpacksReturns struct { + getBuildpacksArgsForCall []FakeActorGetBuildpacksArgs + getBuildpacksReturns struct { result1 []resources.Buildpack result2 v7action.Warnings result3 error @@ -1287,9 +1056,8 @@ type FakeActor struct { } GetCurrentUserStub func() (configv3.User, error) getCurrentUserMutex sync.RWMutex - getCurrentUserArgsForCall []struct { - } - getCurrentUserReturns struct { + getCurrentUserArgsForCall []struct{} + getCurrentUserReturns struct { result1 configv3.User result2 error } @@ -1299,10 +1067,8 @@ type FakeActor struct { } GetDefaultDomainStub func(string) (resources.Domain, v7action.Warnings, error) getDefaultDomainMutex sync.RWMutex - getDefaultDomainArgsForCall []struct { - arg1 string - } - getDefaultDomainReturns struct { + getDefaultDomainArgsForCall []FakeActorGetDefaultDomainArgs + getDefaultDomainReturns struct { result1 resources.Domain result2 v7action.Warnings result3 error @@ -1314,12 +1080,8 @@ type FakeActor struct { } GetDetailedAppSummaryStub func(string, string, bool) (v7action.DetailedApplicationSummary, v7action.Warnings, error) getDetailedAppSummaryMutex sync.RWMutex - getDetailedAppSummaryArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - } - getDetailedAppSummaryReturns struct { + getDetailedAppSummaryArgsForCall []FakeActorGetDetailedAppSummaryArgs + getDetailedAppSummaryReturns struct { result1 v7action.DetailedApplicationSummary result2 v7action.Warnings result3 error @@ -1331,10 +1093,8 @@ type FakeActor struct { } GetDomainStub func(string) (resources.Domain, v7action.Warnings, error) getDomainMutex sync.RWMutex - getDomainArgsForCall []struct { - arg1 string - } - getDomainReturns struct { + getDomainArgsForCall []FakeActorGetDomainArgs + getDomainReturns struct { result1 resources.Domain result2 v7action.Warnings result3 error @@ -1346,10 +1106,8 @@ type FakeActor struct { } GetDomainByNameStub func(string) (resources.Domain, v7action.Warnings, error) getDomainByNameMutex sync.RWMutex - getDomainByNameArgsForCall []struct { - arg1 string - } - getDomainByNameReturns struct { + getDomainByNameArgsForCall []FakeActorGetDomainByNameArgs + getDomainByNameReturns struct { result1 resources.Domain result2 v7action.Warnings result3 error @@ -1361,10 +1119,8 @@ type FakeActor struct { } GetDomainLabelsStub func(string) (map[string]types.NullString, v7action.Warnings, error) getDomainLabelsMutex sync.RWMutex - getDomainLabelsArgsForCall []struct { - arg1 string - } - getDomainLabelsReturns struct { + getDomainLabelsArgsForCall []FakeActorGetDomainLabelsArgs + getDomainLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1376,11 +1132,8 @@ type FakeActor struct { } GetEffectiveIsolationSegmentBySpaceStub func(string, string) (resources.IsolationSegment, v7action.Warnings, error) getEffectiveIsolationSegmentBySpaceMutex sync.RWMutex - getEffectiveIsolationSegmentBySpaceArgsForCall []struct { - arg1 string - arg2 string - } - getEffectiveIsolationSegmentBySpaceReturns struct { + getEffectiveIsolationSegmentBySpaceArgsForCall []FakeActorGetEffectiveIsolationSegmentBySpaceArgs + getEffectiveIsolationSegmentBySpaceReturns struct { result1 resources.IsolationSegment result2 v7action.Warnings result3 error @@ -1392,10 +1145,8 @@ type FakeActor struct { } GetEnvironmentVariableGroupStub func(constanta.EnvironmentVariableGroupName) (v7action.EnvironmentVariableGroup, v7action.Warnings, error) getEnvironmentVariableGroupMutex sync.RWMutex - getEnvironmentVariableGroupArgsForCall []struct { - arg1 constanta.EnvironmentVariableGroupName - } - getEnvironmentVariableGroupReturns struct { + getEnvironmentVariableGroupArgsForCall []FakeActorGetEnvironmentVariableGroupArgs + getEnvironmentVariableGroupReturns struct { result1 v7action.EnvironmentVariableGroup result2 v7action.Warnings result3 error @@ -1407,10 +1158,8 @@ type FakeActor struct { } GetEnvironmentVariableGroupByRevisionStub func(resources.Revision) (v7action.EnvironmentVariableGroup, bool, v7action.Warnings, error) getEnvironmentVariableGroupByRevisionMutex sync.RWMutex - getEnvironmentVariableGroupByRevisionArgsForCall []struct { - arg1 resources.Revision - } - getEnvironmentVariableGroupByRevisionReturns struct { + getEnvironmentVariableGroupByRevisionArgsForCall []FakeActorGetEnvironmentVariableGroupByRevisionArgs + getEnvironmentVariableGroupByRevisionReturns struct { result1 v7action.EnvironmentVariableGroup result2 bool result3 v7action.Warnings @@ -1424,11 +1173,8 @@ type FakeActor struct { } GetEnvironmentVariablesByApplicationNameAndSpaceStub func(string, string) (v7action.EnvironmentVariableGroups, v7action.Warnings, error) getEnvironmentVariablesByApplicationNameAndSpaceMutex sync.RWMutex - getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getEnvironmentVariablesByApplicationNameAndSpaceReturns struct { + getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall []FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs + getEnvironmentVariablesByApplicationNameAndSpaceReturns struct { result1 v7action.EnvironmentVariableGroups result2 v7action.Warnings result3 error @@ -1440,10 +1186,8 @@ type FakeActor struct { } GetFeatureFlagByNameStub func(string) (resources.FeatureFlag, v7action.Warnings, error) getFeatureFlagByNameMutex sync.RWMutex - getFeatureFlagByNameArgsForCall []struct { - arg1 string - } - getFeatureFlagByNameReturns struct { + getFeatureFlagByNameArgsForCall []FakeActorGetFeatureFlagByNameArgs + getFeatureFlagByNameReturns struct { result1 resources.FeatureFlag result2 v7action.Warnings result3 error @@ -1455,9 +1199,8 @@ type FakeActor struct { } GetFeatureFlagsStub func() ([]resources.FeatureFlag, v7action.Warnings, error) getFeatureFlagsMutex sync.RWMutex - getFeatureFlagsArgsForCall []struct { - } - getFeatureFlagsReturns struct { + getFeatureFlagsArgsForCall []struct{} + getFeatureFlagsReturns struct { result1 []resources.FeatureFlag result2 v7action.Warnings result3 error @@ -1469,9 +1212,8 @@ type FakeActor struct { } GetGlobalRunningSecurityGroupsStub func() ([]resources.SecurityGroup, v7action.Warnings, error) getGlobalRunningSecurityGroupsMutex sync.RWMutex - getGlobalRunningSecurityGroupsArgsForCall []struct { - } - getGlobalRunningSecurityGroupsReturns struct { + getGlobalRunningSecurityGroupsArgsForCall []struct{} + getGlobalRunningSecurityGroupsReturns struct { result1 []resources.SecurityGroup result2 v7action.Warnings result3 error @@ -1483,9 +1225,8 @@ type FakeActor struct { } GetGlobalStagingSecurityGroupsStub func() ([]resources.SecurityGroup, v7action.Warnings, error) getGlobalStagingSecurityGroupsMutex sync.RWMutex - getGlobalStagingSecurityGroupsArgsForCall []struct { - } - getGlobalStagingSecurityGroupsReturns struct { + getGlobalStagingSecurityGroupsArgsForCall []struct{} + getGlobalStagingSecurityGroupsReturns struct { result1 []resources.SecurityGroup result2 v7action.Warnings result3 error @@ -1497,9 +1238,8 @@ type FakeActor struct { } GetInfoResponseStub func() (v7action.Info, v7action.Warnings, error) getInfoResponseMutex sync.RWMutex - getInfoResponseArgsForCall []struct { - } - getInfoResponseReturns struct { + getInfoResponseArgsForCall []struct{} + getInfoResponseReturns struct { result1 v7action.Info result2 v7action.Warnings result3 error @@ -1511,10 +1251,8 @@ type FakeActor struct { } GetIsolationSegmentByNameStub func(string) (resources.IsolationSegment, v7action.Warnings, error) getIsolationSegmentByNameMutex sync.RWMutex - getIsolationSegmentByNameArgsForCall []struct { - arg1 string - } - getIsolationSegmentByNameReturns struct { + getIsolationSegmentByNameArgsForCall []FakeActorGetIsolationSegmentByNameArgs + getIsolationSegmentByNameReturns struct { result1 resources.IsolationSegment result2 v7action.Warnings result3 error @@ -1526,9 +1264,8 @@ type FakeActor struct { } GetIsolationSegmentSummariesStub func() ([]v7action.IsolationSegmentSummary, v7action.Warnings, error) getIsolationSegmentSummariesMutex sync.RWMutex - getIsolationSegmentSummariesArgsForCall []struct { - } - getIsolationSegmentSummariesReturns struct { + getIsolationSegmentSummariesArgsForCall []struct{} + getIsolationSegmentSummariesReturns struct { result1 []v7action.IsolationSegmentSummary result2 v7action.Warnings result3 error @@ -1540,10 +1277,8 @@ type FakeActor struct { } GetIsolationSegmentsByOrganizationStub func(string) ([]resources.IsolationSegment, v7action.Warnings, error) getIsolationSegmentsByOrganizationMutex sync.RWMutex - getIsolationSegmentsByOrganizationArgsForCall []struct { - arg1 string - } - getIsolationSegmentsByOrganizationReturns struct { + getIsolationSegmentsByOrganizationArgsForCall []FakeActorGetIsolationSegmentsByOrganizationArgs + getIsolationSegmentsByOrganizationReturns struct { result1 []resources.IsolationSegment result2 v7action.Warnings result3 error @@ -1555,10 +1290,8 @@ type FakeActor struct { } GetLatestActiveDeploymentForAppStub func(string) (resources.Deployment, v7action.Warnings, error) getLatestActiveDeploymentForAppMutex sync.RWMutex - getLatestActiveDeploymentForAppArgsForCall []struct { - arg1 string - } - getLatestActiveDeploymentForAppReturns struct { + getLatestActiveDeploymentForAppArgsForCall []FakeActorGetLatestActiveDeploymentForAppArgs + getLatestActiveDeploymentForAppReturns struct { result1 resources.Deployment result2 v7action.Warnings result3 error @@ -1570,9 +1303,8 @@ type FakeActor struct { } GetLoginPromptsStub func() (map[string]coreconfig.AuthPrompt, error) getLoginPromptsMutex sync.RWMutex - getLoginPromptsArgsForCall []struct { - } - getLoginPromptsReturns struct { + getLoginPromptsArgsForCall []struct{} + getLoginPromptsReturns struct { result1 map[string]coreconfig.AuthPrompt result2 error } @@ -1582,10 +1314,8 @@ type FakeActor struct { } GetNewestReadyPackageForApplicationStub func(resources.Application) (resources.Package, v7action.Warnings, error) getNewestReadyPackageForApplicationMutex sync.RWMutex - getNewestReadyPackageForApplicationArgsForCall []struct { - arg1 resources.Application - } - getNewestReadyPackageForApplicationReturns struct { + getNewestReadyPackageForApplicationArgsForCall []FakeActorGetNewestReadyPackageForApplicationArgs + getNewestReadyPackageForApplicationReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -1597,10 +1327,8 @@ type FakeActor struct { } GetOrgUsersByRoleTypeStub func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) getOrgUsersByRoleTypeMutex sync.RWMutex - getOrgUsersByRoleTypeArgsForCall []struct { - arg1 string - } - getOrgUsersByRoleTypeReturns struct { + getOrgUsersByRoleTypeArgsForCall []FakeActorGetOrgUsersByRoleTypeArgs + getOrgUsersByRoleTypeReturns struct { result1 map[constanta.RoleType][]resources.User result2 v7action.Warnings result3 error @@ -1612,10 +1340,8 @@ type FakeActor struct { } GetOrganizationByNameStub func(string) (resources.Organization, v7action.Warnings, error) getOrganizationByNameMutex sync.RWMutex - getOrganizationByNameArgsForCall []struct { - arg1 string - } - getOrganizationByNameReturns struct { + getOrganizationByNameArgsForCall []FakeActorGetOrganizationByNameArgs + getOrganizationByNameReturns struct { result1 resources.Organization result2 v7action.Warnings result3 error @@ -1627,11 +1353,8 @@ type FakeActor struct { } GetOrganizationDomainsStub func(string, string) ([]resources.Domain, v7action.Warnings, error) getOrganizationDomainsMutex sync.RWMutex - getOrganizationDomainsArgsForCall []struct { - arg1 string - arg2 string - } - getOrganizationDomainsReturns struct { + getOrganizationDomainsArgsForCall []FakeActorGetOrganizationDomainsArgs + getOrganizationDomainsReturns struct { result1 []resources.Domain result2 v7action.Warnings result3 error @@ -1643,10 +1366,8 @@ type FakeActor struct { } GetOrganizationLabelsStub func(string) (map[string]types.NullString, v7action.Warnings, error) getOrganizationLabelsMutex sync.RWMutex - getOrganizationLabelsArgsForCall []struct { - arg1 string - } - getOrganizationLabelsReturns struct { + getOrganizationLabelsArgsForCall []FakeActorGetOrganizationLabelsArgs + getOrganizationLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1658,10 +1379,8 @@ type FakeActor struct { } GetOrganizationQuotaByNameStub func(string) (resources.OrganizationQuota, v7action.Warnings, error) getOrganizationQuotaByNameMutex sync.RWMutex - getOrganizationQuotaByNameArgsForCall []struct { - arg1 string - } - getOrganizationQuotaByNameReturns struct { + getOrganizationQuotaByNameArgsForCall []FakeActorGetOrganizationQuotaByNameArgs + getOrganizationQuotaByNameReturns struct { result1 resources.OrganizationQuota result2 v7action.Warnings result3 error @@ -1673,9 +1392,8 @@ type FakeActor struct { } GetOrganizationQuotasStub func() ([]resources.OrganizationQuota, v7action.Warnings, error) getOrganizationQuotasMutex sync.RWMutex - getOrganizationQuotasArgsForCall []struct { - } - getOrganizationQuotasReturns struct { + getOrganizationQuotasArgsForCall []struct{} + getOrganizationQuotasReturns struct { result1 []resources.OrganizationQuota result2 v7action.Warnings result3 error @@ -1687,10 +1405,8 @@ type FakeActor struct { } GetOrganizationSpacesStub func(string) ([]resources.Space, v7action.Warnings, error) getOrganizationSpacesMutex sync.RWMutex - getOrganizationSpacesArgsForCall []struct { - arg1 string - } - getOrganizationSpacesReturns struct { + getOrganizationSpacesArgsForCall []FakeActorGetOrganizationSpacesArgs + getOrganizationSpacesReturns struct { result1 []resources.Space result2 v7action.Warnings result3 error @@ -1702,11 +1418,8 @@ type FakeActor struct { } GetOrganizationSpacesWithLabelSelectorStub func(string, string) ([]resources.Space, v7action.Warnings, error) getOrganizationSpacesWithLabelSelectorMutex sync.RWMutex - getOrganizationSpacesWithLabelSelectorArgsForCall []struct { - arg1 string - arg2 string - } - getOrganizationSpacesWithLabelSelectorReturns struct { + getOrganizationSpacesWithLabelSelectorArgsForCall []FakeActorGetOrganizationSpacesWithLabelSelectorArgs + getOrganizationSpacesWithLabelSelectorReturns struct { result1 []resources.Space result2 v7action.Warnings result3 error @@ -1718,10 +1431,8 @@ type FakeActor struct { } GetOrganizationSummaryByNameStub func(string) (v7action.OrganizationSummary, v7action.Warnings, error) getOrganizationSummaryByNameMutex sync.RWMutex - getOrganizationSummaryByNameArgsForCall []struct { - arg1 string - } - getOrganizationSummaryByNameReturns struct { + getOrganizationSummaryByNameArgsForCall []FakeActorGetOrganizationSummaryByNameArgs + getOrganizationSummaryByNameReturns struct { result1 v7action.OrganizationSummary result2 v7action.Warnings result3 error @@ -1733,10 +1444,8 @@ type FakeActor struct { } GetOrganizationsStub func(string) ([]resources.Organization, v7action.Warnings, error) getOrganizationsMutex sync.RWMutex - getOrganizationsArgsForCall []struct { - arg1 string - } - getOrganizationsReturns struct { + getOrganizationsArgsForCall []FakeActorGetOrganizationsArgs + getOrganizationsReturns struct { result1 []resources.Organization result2 v7action.Warnings result3 error @@ -1748,11 +1457,8 @@ type FakeActor struct { } GetProcessByTypeAndApplicationStub func(string, string) (resources.Process, v7action.Warnings, error) getProcessByTypeAndApplicationMutex sync.RWMutex - getProcessByTypeAndApplicationArgsForCall []struct { - arg1 string - arg2 string - } - getProcessByTypeAndApplicationReturns struct { + getProcessByTypeAndApplicationArgsForCall []FakeActorGetProcessByTypeAndApplicationArgs + getProcessByTypeAndApplicationReturns struct { result1 resources.Process result2 v7action.Warnings result3 error @@ -1764,11 +1470,8 @@ type FakeActor struct { } GetRawApplicationManifestByNameAndSpaceStub func(string, string) ([]byte, v7action.Warnings, error) getRawApplicationManifestByNameAndSpaceMutex sync.RWMutex - getRawApplicationManifestByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getRawApplicationManifestByNameAndSpaceReturns struct { + getRawApplicationManifestByNameAndSpaceArgsForCall []FakeActorGetRawApplicationManifestByNameAndSpaceArgs + getRawApplicationManifestByNameAndSpaceReturns struct { result1 []byte result2 v7action.Warnings result3 error @@ -1780,11 +1483,8 @@ type FakeActor struct { } GetRecentEventsByApplicationNameAndSpaceStub func(string, string) ([]v7action.Event, v7action.Warnings, error) getRecentEventsByApplicationNameAndSpaceMutex sync.RWMutex - getRecentEventsByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getRecentEventsByApplicationNameAndSpaceReturns struct { + getRecentEventsByApplicationNameAndSpaceArgsForCall []FakeActorGetRecentEventsByApplicationNameAndSpaceArgs + getRecentEventsByApplicationNameAndSpaceReturns struct { result1 []v7action.Event result2 v7action.Warnings result3 error @@ -1796,12 +1496,8 @@ type FakeActor struct { } GetRecentLogsForApplicationByNameAndSpaceStub func(string, string, sharedaction.LogCacheClient) ([]sharedaction.LogMessage, v7action.Warnings, error) getRecentLogsForApplicationByNameAndSpaceMutex sync.RWMutex - getRecentLogsForApplicationByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 sharedaction.LogCacheClient - } - getRecentLogsForApplicationByNameAndSpaceReturns struct { + getRecentLogsForApplicationByNameAndSpaceArgsForCall []FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs + getRecentLogsForApplicationByNameAndSpaceReturns struct { result1 []sharedaction.LogMessage result2 v7action.Warnings result3 error @@ -1813,11 +1509,8 @@ type FakeActor struct { } GetRevisionByApplicationAndVersionStub func(string, int) (resources.Revision, v7action.Warnings, error) getRevisionByApplicationAndVersionMutex sync.RWMutex - getRevisionByApplicationAndVersionArgsForCall []struct { - arg1 string - arg2 int - } - getRevisionByApplicationAndVersionReturns struct { + getRevisionByApplicationAndVersionArgsForCall []FakeActorGetRevisionByApplicationAndVersionArgs + getRevisionByApplicationAndVersionReturns struct { result1 resources.Revision result2 v7action.Warnings result3 error @@ -1829,11 +1522,8 @@ type FakeActor struct { } GetRevisionsByApplicationNameAndSpaceStub func(string, string) ([]resources.Revision, v7action.Warnings, error) getRevisionsByApplicationNameAndSpaceMutex sync.RWMutex - getRevisionsByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getRevisionsByApplicationNameAndSpaceReturns struct { + getRevisionsByApplicationNameAndSpaceArgsForCall []FakeActorGetRevisionsByApplicationNameAndSpaceArgs + getRevisionsByApplicationNameAndSpaceReturns struct { result1 []resources.Revision result2 v7action.Warnings result3 error @@ -1845,9 +1535,8 @@ type FakeActor struct { } GetRootResponseStub func() (v7action.Root, v7action.Warnings, error) getRootResponseMutex sync.RWMutex - getRootResponseArgsForCall []struct { - } - getRootResponseReturns struct { + getRootResponseArgsForCall []struct{} + getRootResponseReturns struct { result1 v7action.Root result2 v7action.Warnings result3 error @@ -1859,13 +1548,8 @@ type FakeActor struct { } GetRouteByAttributesStub func(resources.Domain, string, string, int) (resources.Route, v7action.Warnings, error) getRouteByAttributesMutex sync.RWMutex - getRouteByAttributesArgsForCall []struct { - arg1 resources.Domain - arg2 string - arg3 string - arg4 int - } - getRouteByAttributesReturns struct { + getRouteByAttributesArgsForCall []FakeActorGetRouteByAttributesArgs + getRouteByAttributesReturns struct { result1 resources.Route result2 v7action.Warnings result3 error @@ -1877,11 +1561,8 @@ type FakeActor struct { } GetRouteDestinationByAppGUIDStub func(resources.Route, string) (resources.RouteDestination, error) getRouteDestinationByAppGUIDMutex sync.RWMutex - getRouteDestinationByAppGUIDArgsForCall []struct { - arg1 resources.Route - arg2 string - } - getRouteDestinationByAppGUIDReturns struct { + getRouteDestinationByAppGUIDArgsForCall []FakeActorGetRouteDestinationByAppGUIDArgs + getRouteDestinationByAppGUIDReturns struct { result1 resources.RouteDestination result2 error } @@ -1891,11 +1572,8 @@ type FakeActor struct { } GetRouteLabelsStub func(string, string) (map[string]types.NullString, v7action.Warnings, error) getRouteLabelsMutex sync.RWMutex - getRouteLabelsArgsForCall []struct { - arg1 string - arg2 string - } - getRouteLabelsReturns struct { + getRouteLabelsArgsForCall []FakeActorGetRouteLabelsArgs + getRouteLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1907,12 +1585,8 @@ type FakeActor struct { } GetRoutePoliciesByRouteStub func(string, string, string) ([]resources.RoutePolicy, v7action.Warnings, error) getRoutePoliciesByRouteMutex sync.RWMutex - getRoutePoliciesByRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getRoutePoliciesByRouteReturns struct { + getRoutePoliciesByRouteArgsForCall []FakeActorGetRoutePoliciesByRouteArgs + getRoutePoliciesByRouteReturns struct { result1 []resources.RoutePolicy result2 v7action.Warnings result3 error @@ -1924,14 +1598,8 @@ type FakeActor struct { } GetRoutePoliciesForSpaceStub func(string, string, string, string, string) ([]v7action.RoutePolicyWithRoute, v7action.Warnings, error) getRoutePoliciesForSpaceMutex sync.RWMutex - getRoutePoliciesForSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 string - arg5 string - } - getRoutePoliciesForSpaceReturns struct { + getRoutePoliciesForSpaceArgsForCall []FakeActorGetRoutePoliciesForSpaceArgs + getRoutePoliciesForSpaceReturns struct { result1 []v7action.RoutePolicyWithRoute result2 v7action.Warnings result3 error @@ -1943,12 +1611,8 @@ type FakeActor struct { } GetRoutePolicyLabelsStub func(string, string, string) (map[string]types.NullString, v7action.Warnings, error) getRoutePolicyLabelsMutex sync.RWMutex - getRoutePolicyLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getRoutePolicyLabelsReturns struct { + getRoutePolicyLabelsArgsForCall []FakeActorGetRoutePolicyLabelsArgs + getRoutePolicyLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -1960,10 +1624,8 @@ type FakeActor struct { } GetRouteSummariesStub func([]resources.Route) ([]v7action.RouteSummary, v7action.Warnings, error) getRouteSummariesMutex sync.RWMutex - getRouteSummariesArgsForCall []struct { - arg1 []resources.Route - } - getRouteSummariesReturns struct { + getRouteSummariesArgsForCall []FakeActorGetRouteSummariesArgs + getRouteSummariesReturns struct { result1 []v7action.RouteSummary result2 v7action.Warnings result3 error @@ -1975,9 +1637,8 @@ type FakeActor struct { } GetRouterGroupsStub func() ([]v7action.RouterGroup, error) getRouterGroupsMutex sync.RWMutex - getRouterGroupsArgsForCall []struct { - } - getRouterGroupsReturns struct { + getRouterGroupsArgsForCall []struct{} + getRouterGroupsReturns struct { result1 []v7action.RouterGroup result2 error } @@ -1987,11 +1648,8 @@ type FakeActor struct { } GetRoutesByOrgStub func(string, string) ([]resources.Route, v7action.Warnings, error) getRoutesByOrgMutex sync.RWMutex - getRoutesByOrgArgsForCall []struct { - arg1 string - arg2 string - } - getRoutesByOrgReturns struct { + getRoutesByOrgArgsForCall []FakeActorGetRoutesByOrgArgs + getRoutesByOrgReturns struct { result1 []resources.Route result2 v7action.Warnings result3 error @@ -2003,11 +1661,8 @@ type FakeActor struct { } GetRoutesBySpaceStub func(string, string) ([]resources.Route, v7action.Warnings, error) getRoutesBySpaceMutex sync.RWMutex - getRoutesBySpaceArgsForCall []struct { - arg1 string - arg2 string - } - getRoutesBySpaceReturns struct { + getRoutesBySpaceArgsForCall []FakeActorGetRoutesBySpaceArgs + getRoutesBySpaceReturns struct { result1 []resources.Route result2 v7action.Warnings result3 error @@ -2019,10 +1674,8 @@ type FakeActor struct { } GetSSHEnabledStub func(string) (ccv3.SSHEnabled, v7action.Warnings, error) getSSHEnabledMutex sync.RWMutex - getSSHEnabledArgsForCall []struct { - arg1 string - } - getSSHEnabledReturns struct { + getSSHEnabledArgsForCall []FakeActorGetSSHEnabledArgs + getSSHEnabledReturns struct { result1 ccv3.SSHEnabled result2 v7action.Warnings result3 error @@ -2034,11 +1687,8 @@ type FakeActor struct { } GetSSHEnabledByAppNameStub func(string, string) (ccv3.SSHEnabled, v7action.Warnings, error) getSSHEnabledByAppNameMutex sync.RWMutex - getSSHEnabledByAppNameArgsForCall []struct { - arg1 string - arg2 string - } - getSSHEnabledByAppNameReturns struct { + getSSHEnabledByAppNameArgsForCall []FakeActorGetSSHEnabledByAppNameArgs + getSSHEnabledByAppNameReturns struct { result1 ccv3.SSHEnabled result2 v7action.Warnings result3 error @@ -2050,9 +1700,8 @@ type FakeActor struct { } GetSSHPasscodeStub func() (string, error) getSSHPasscodeMutex sync.RWMutex - getSSHPasscodeArgsForCall []struct { - } - getSSHPasscodeReturns struct { + getSSHPasscodeArgsForCall []struct{} + getSSHPasscodeReturns struct { result1 string result2 error } @@ -2062,13 +1711,8 @@ type FakeActor struct { } GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub func(string, string, string, uint) (v7action.SSHAuthentication, v7action.Warnings, error) getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex sync.RWMutex - getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 uint - } - getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns struct { + getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall []FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs + getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns struct { result1 v7action.SSHAuthentication result2 v7action.Warnings result3 error @@ -2080,10 +1724,8 @@ type FakeActor struct { } GetSecurityGroupStub func(string) (resources.SecurityGroup, v7action.Warnings, error) getSecurityGroupMutex sync.RWMutex - getSecurityGroupArgsForCall []struct { - arg1 string - } - getSecurityGroupReturns struct { + getSecurityGroupArgsForCall []FakeActorGetSecurityGroupArgs + getSecurityGroupReturns struct { result1 resources.SecurityGroup result2 v7action.Warnings result3 error @@ -2095,10 +1737,8 @@ type FakeActor struct { } GetSecurityGroupSummaryStub func(string) (v7action.SecurityGroupSummary, v7action.Warnings, error) getSecurityGroupSummaryMutex sync.RWMutex - getSecurityGroupSummaryArgsForCall []struct { - arg1 string - } - getSecurityGroupSummaryReturns struct { + getSecurityGroupSummaryArgsForCall []FakeActorGetSecurityGroupSummaryArgs + getSecurityGroupSummaryReturns struct { result1 v7action.SecurityGroupSummary result2 v7action.Warnings result3 error @@ -2110,9 +1750,8 @@ type FakeActor struct { } GetSecurityGroupsStub func() ([]v7action.SecurityGroupSummary, v7action.Warnings, error) getSecurityGroupsMutex sync.RWMutex - getSecurityGroupsArgsForCall []struct { - } - getSecurityGroupsReturns struct { + getSecurityGroupsArgsForCall []struct{} + getSecurityGroupsReturns struct { result1 []v7action.SecurityGroupSummary result2 v7action.Warnings result3 error @@ -2124,12 +1763,8 @@ type FakeActor struct { } GetServiceAccessStub func(string, string, string) ([]v7action.ServicePlanAccess, v7action.Warnings, error) getServiceAccessMutex sync.RWMutex - getServiceAccessArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getServiceAccessReturns struct { + getServiceAccessArgsForCall []FakeActorGetServiceAccessArgs + getServiceAccessReturns struct { result1 []v7action.ServicePlanAccess result2 v7action.Warnings result3 error @@ -2139,12 +1774,36 @@ type FakeActor struct { result2 v7action.Warnings result3 error } + GetServiceAccountByNameAndSpaceStub func(string, string) (resources.ServiceAccount, v7action.Warnings, error) + getServiceAccountByNameAndSpaceMutex sync.RWMutex + getServiceAccountByNameAndSpaceArgsForCall []FakeActorGetServiceAccountByNameAndSpaceArgs + getServiceAccountByNameAndSpaceReturns struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + } + getServiceAccountByNameAndSpaceReturnsOnCall map[int]struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + } + GetServiceAccountsInSpaceStub func(string) ([]resources.ServiceAccount, v7action.Warnings, error) + getServiceAccountsInSpaceMutex sync.RWMutex + getServiceAccountsInSpaceArgsForCall []FakeActorGetServiceAccountsInSpaceArgs + getServiceAccountsInSpaceReturns struct { + result1 []resources.ServiceAccount + result2 v7action.Warnings + result3 error + } + getServiceAccountsInSpaceReturnsOnCall map[int]struct { + result1 []resources.ServiceAccount + result2 v7action.Warnings + result3 error + } GetServiceBrokerByNameStub func(string) (resources.ServiceBroker, v7action.Warnings, error) getServiceBrokerByNameMutex sync.RWMutex - getServiceBrokerByNameArgsForCall []struct { - arg1 string - } - getServiceBrokerByNameReturns struct { + getServiceBrokerByNameArgsForCall []FakeActorGetServiceBrokerByNameArgs + getServiceBrokerByNameReturns struct { result1 resources.ServiceBroker result2 v7action.Warnings result3 error @@ -2156,10 +1815,8 @@ type FakeActor struct { } GetServiceBrokerLabelsStub func(string) (map[string]types.NullString, v7action.Warnings, error) getServiceBrokerLabelsMutex sync.RWMutex - getServiceBrokerLabelsArgsForCall []struct { - arg1 string - } - getServiceBrokerLabelsReturns struct { + getServiceBrokerLabelsArgsForCall []FakeActorGetServiceBrokerLabelsArgs + getServiceBrokerLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2171,9 +1828,8 @@ type FakeActor struct { } GetServiceBrokersStub func() ([]resources.ServiceBroker, v7action.Warnings, error) getServiceBrokersMutex sync.RWMutex - getServiceBrokersArgsForCall []struct { - } - getServiceBrokersReturns struct { + getServiceBrokersArgsForCall []struct{} + getServiceBrokersReturns struct { result1 []resources.ServiceBroker result2 v7action.Warnings result3 error @@ -2185,10 +1841,8 @@ type FakeActor struct { } GetServiceInstanceByGUIDStub func(string) (resources.ServiceInstance, v7action.Warnings, error) getServiceInstanceByGUIDMutex sync.RWMutex - getServiceInstanceByGUIDArgsForCall []struct { - arg1 string - } - getServiceInstanceByGUIDReturns struct { + getServiceInstanceByGUIDArgsForCall []FakeActorGetServiceInstanceByGUIDArgs + getServiceInstanceByGUIDReturns struct { result1 resources.ServiceInstance result2 v7action.Warnings result3 error @@ -2200,11 +1854,8 @@ type FakeActor struct { } GetServiceInstanceByNameAndSpaceStub func(string, string) (resources.ServiceInstance, v7action.Warnings, error) getServiceInstanceByNameAndSpaceMutex sync.RWMutex - getServiceInstanceByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - } - getServiceInstanceByNameAndSpaceReturns struct { + getServiceInstanceByNameAndSpaceArgsForCall []FakeActorGetServiceInstanceByNameAndSpaceArgs + getServiceInstanceByNameAndSpaceReturns struct { result1 resources.ServiceInstance result2 v7action.Warnings result3 error @@ -2216,12 +1867,8 @@ type FakeActor struct { } GetServiceInstanceDetailsStub func(string, string, bool) (v7action.ServiceInstanceDetails, v7action.Warnings, error) getServiceInstanceDetailsMutex sync.RWMutex - getServiceInstanceDetailsArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - } - getServiceInstanceDetailsReturns struct { + getServiceInstanceDetailsArgsForCall []FakeActorGetServiceInstanceDetailsArgs + getServiceInstanceDetailsReturns struct { result1 v7action.ServiceInstanceDetails result2 v7action.Warnings result3 error @@ -2233,11 +1880,8 @@ type FakeActor struct { } GetServiceInstanceLabelsStub func(string, string) (map[string]types.NullString, v7action.Warnings, error) getServiceInstanceLabelsMutex sync.RWMutex - getServiceInstanceLabelsArgsForCall []struct { - arg1 string - arg2 string - } - getServiceInstanceLabelsReturns struct { + getServiceInstanceLabelsArgsForCall []FakeActorGetServiceInstanceLabelsArgs + getServiceInstanceLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2249,11 +1893,8 @@ type FakeActor struct { } GetServiceInstanceParametersStub func(string, string) (v7action.ServiceInstanceParameters, v7action.Warnings, error) getServiceInstanceParametersMutex sync.RWMutex - getServiceInstanceParametersArgsForCall []struct { - arg1 string - arg2 string - } - getServiceInstanceParametersReturns struct { + getServiceInstanceParametersArgsForCall []FakeActorGetServiceInstanceParametersArgs + getServiceInstanceParametersReturns struct { result1 v7action.ServiceInstanceParameters result2 v7action.Warnings result3 error @@ -2265,11 +1906,8 @@ type FakeActor struct { } GetServiceInstancesForSpaceStub func(string, bool) ([]v7action.ServiceInstance, v7action.Warnings, error) getServiceInstancesForSpaceMutex sync.RWMutex - getServiceInstancesForSpaceArgsForCall []struct { - arg1 string - arg2 bool - } - getServiceInstancesForSpaceReturns struct { + getServiceInstancesForSpaceArgsForCall []FakeActorGetServiceInstancesForSpaceArgs + getServiceInstancesForSpaceReturns struct { result1 []v7action.ServiceInstance result2 v7action.Warnings result3 error @@ -2281,12 +1919,8 @@ type FakeActor struct { } GetServiceKeyByServiceInstanceAndNameStub func(string, string, string) (resources.ServiceCredentialBinding, v7action.Warnings, error) getServiceKeyByServiceInstanceAndNameMutex sync.RWMutex - getServiceKeyByServiceInstanceAndNameArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getServiceKeyByServiceInstanceAndNameReturns struct { + getServiceKeyByServiceInstanceAndNameArgsForCall []FakeActorGetServiceKeyByServiceInstanceAndNameArgs + getServiceKeyByServiceInstanceAndNameReturns struct { result1 resources.ServiceCredentialBinding result2 v7action.Warnings result3 error @@ -2298,12 +1932,8 @@ type FakeActor struct { } GetServiceKeyDetailsByServiceInstanceAndNameStub func(string, string, string) (resources.ServiceCredentialBindingDetails, v7action.Warnings, error) getServiceKeyDetailsByServiceInstanceAndNameMutex sync.RWMutex - getServiceKeyDetailsByServiceInstanceAndNameArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getServiceKeyDetailsByServiceInstanceAndNameReturns struct { + getServiceKeyDetailsByServiceInstanceAndNameArgsForCall []FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs + getServiceKeyDetailsByServiceInstanceAndNameReturns struct { result1 resources.ServiceCredentialBindingDetails result2 v7action.Warnings result3 error @@ -2315,11 +1945,8 @@ type FakeActor struct { } GetServiceKeysByServiceInstanceStub func(string, string) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) getServiceKeysByServiceInstanceMutex sync.RWMutex - getServiceKeysByServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - } - getServiceKeysByServiceInstanceReturns struct { + getServiceKeysByServiceInstanceArgsForCall []FakeActorGetServiceKeysByServiceInstanceArgs + getServiceKeysByServiceInstanceReturns struct { result1 []resources.ServiceCredentialBinding result2 v7action.Warnings result3 error @@ -2331,11 +1958,8 @@ type FakeActor struct { } GetServiceOfferingLabelsStub func(string, string) (map[string]types.NullString, v7action.Warnings, error) getServiceOfferingLabelsMutex sync.RWMutex - getServiceOfferingLabelsArgsForCall []struct { - arg1 string - arg2 string - } - getServiceOfferingLabelsReturns struct { + getServiceOfferingLabelsArgsForCall []FakeActorGetServiceOfferingLabelsArgs + getServiceOfferingLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2347,12 +1971,8 @@ type FakeActor struct { } GetServicePlanByNameOfferingAndBrokerStub func(string, string, string) (resources.ServicePlan, v7action.Warnings, error) getServicePlanByNameOfferingAndBrokerMutex sync.RWMutex - getServicePlanByNameOfferingAndBrokerArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getServicePlanByNameOfferingAndBrokerReturns struct { + getServicePlanByNameOfferingAndBrokerArgsForCall []FakeActorGetServicePlanByNameOfferingAndBrokerArgs + getServicePlanByNameOfferingAndBrokerReturns struct { result1 resources.ServicePlan result2 v7action.Warnings result3 error @@ -2364,12 +1984,8 @@ type FakeActor struct { } GetServicePlanLabelsStub func(string, string, string) (map[string]types.NullString, v7action.Warnings, error) getServicePlanLabelsMutex sync.RWMutex - getServicePlanLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getServicePlanLabelsReturns struct { + getServicePlanLabelsArgsForCall []FakeActorGetServicePlanLabelsArgs + getServicePlanLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2381,11 +1997,8 @@ type FakeActor struct { } GetSpaceByNameAndOrganizationStub func(string, string) (resources.Space, v7action.Warnings, error) getSpaceByNameAndOrganizationMutex sync.RWMutex - getSpaceByNameAndOrganizationArgsForCall []struct { - arg1 string - arg2 string - } - getSpaceByNameAndOrganizationReturns struct { + getSpaceByNameAndOrganizationArgsForCall []FakeActorGetSpaceByNameAndOrganizationArgs + getSpaceByNameAndOrganizationReturns struct { result1 resources.Space result2 v7action.Warnings result3 error @@ -2397,12 +2010,8 @@ type FakeActor struct { } GetSpaceFeatureStub func(string, string, string) (bool, v7action.Warnings, error) getSpaceFeatureMutex sync.RWMutex - getSpaceFeatureArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - getSpaceFeatureReturns struct { + getSpaceFeatureArgsForCall []FakeActorGetSpaceFeatureArgs + getSpaceFeatureReturns struct { result1 bool result2 v7action.Warnings result3 error @@ -2414,11 +2023,8 @@ type FakeActor struct { } GetSpaceLabelsStub func(string, string) (map[string]types.NullString, v7action.Warnings, error) getSpaceLabelsMutex sync.RWMutex - getSpaceLabelsArgsForCall []struct { - arg1 string - arg2 string - } - getSpaceLabelsReturns struct { + getSpaceLabelsArgsForCall []FakeActorGetSpaceLabelsArgs + getSpaceLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2430,11 +2036,8 @@ type FakeActor struct { } GetSpaceQuotaByNameStub func(string, string) (resources.SpaceQuota, v7action.Warnings, error) getSpaceQuotaByNameMutex sync.RWMutex - getSpaceQuotaByNameArgsForCall []struct { - arg1 string - arg2 string - } - getSpaceQuotaByNameReturns struct { + getSpaceQuotaByNameArgsForCall []FakeActorGetSpaceQuotaByNameArgs + getSpaceQuotaByNameReturns struct { result1 resources.SpaceQuota result2 v7action.Warnings result3 error @@ -2446,10 +2049,8 @@ type FakeActor struct { } GetSpaceQuotasByOrgGUIDStub func(string) ([]resources.SpaceQuota, v7action.Warnings, error) getSpaceQuotasByOrgGUIDMutex sync.RWMutex - getSpaceQuotasByOrgGUIDArgsForCall []struct { - arg1 string - } - getSpaceQuotasByOrgGUIDReturns struct { + getSpaceQuotasByOrgGUIDArgsForCall []FakeActorGetSpaceQuotasByOrgGUIDArgs + getSpaceQuotasByOrgGUIDReturns struct { result1 []resources.SpaceQuota result2 v7action.Warnings result3 error @@ -2461,11 +2062,8 @@ type FakeActor struct { } GetSpaceSummaryByNameAndOrganizationStub func(string, string) (v7action.SpaceSummary, v7action.Warnings, error) getSpaceSummaryByNameAndOrganizationMutex sync.RWMutex - getSpaceSummaryByNameAndOrganizationArgsForCall []struct { - arg1 string - arg2 string - } - getSpaceSummaryByNameAndOrganizationReturns struct { + getSpaceSummaryByNameAndOrganizationArgsForCall []FakeActorGetSpaceSummaryByNameAndOrganizationArgs + getSpaceSummaryByNameAndOrganizationReturns struct { result1 v7action.SpaceSummary result2 v7action.Warnings result3 error @@ -2477,10 +2075,8 @@ type FakeActor struct { } GetSpaceUsersByRoleTypeStub func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) getSpaceUsersByRoleTypeMutex sync.RWMutex - getSpaceUsersByRoleTypeArgsForCall []struct { - arg1 string - } - getSpaceUsersByRoleTypeReturns struct { + getSpaceUsersByRoleTypeArgsForCall []FakeActorGetSpaceUsersByRoleTypeArgs + getSpaceUsersByRoleTypeReturns struct { result1 map[constanta.RoleType][]resources.User result2 v7action.Warnings result3 error @@ -2492,10 +2088,8 @@ type FakeActor struct { } GetStackByNameStub func(string) (resources.Stack, v7action.Warnings, error) getStackByNameMutex sync.RWMutex - getStackByNameArgsForCall []struct { - arg1 string - } - getStackByNameReturns struct { + getStackByNameArgsForCall []FakeActorGetStackByNameArgs + getStackByNameReturns struct { result1 resources.Stack result2 v7action.Warnings result3 error @@ -2507,10 +2101,8 @@ type FakeActor struct { } GetStackLabelsStub func(string) (map[string]types.NullString, v7action.Warnings, error) getStackLabelsMutex sync.RWMutex - getStackLabelsArgsForCall []struct { - arg1 string - } - getStackLabelsReturns struct { + getStackLabelsArgsForCall []FakeActorGetStackLabelsArgs + getStackLabelsReturns struct { result1 map[string]types.NullString result2 v7action.Warnings result3 error @@ -2522,10 +2114,8 @@ type FakeActor struct { } GetStacksStub func(string) ([]resources.Stack, v7action.Warnings, error) getStacksMutex sync.RWMutex - getStacksArgsForCall []struct { - arg1 string - } - getStacksReturns struct { + getStacksArgsForCall []FakeActorGetStacksArgs + getStacksReturns struct { result1 []resources.Stack result2 v7action.Warnings result3 error @@ -2537,12 +2127,8 @@ type FakeActor struct { } GetStreamingLogsForApplicationByNameAndSpaceStub func(string, string, sharedaction.LogCacheClient) (<-chan sharedaction.LogMessage, <-chan error, context.CancelFunc, v7action.Warnings, error) getStreamingLogsForApplicationByNameAndSpaceMutex sync.RWMutex - getStreamingLogsForApplicationByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 sharedaction.LogCacheClient - } - getStreamingLogsForApplicationByNameAndSpaceReturns struct { + getStreamingLogsForApplicationByNameAndSpaceArgsForCall []FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs + getStreamingLogsForApplicationByNameAndSpaceReturns struct { result1 <-chan sharedaction.LogMessage result2 <-chan error result3 context.CancelFunc @@ -2558,11 +2144,8 @@ type FakeActor struct { } GetTaskBySequenceIDAndApplicationStub func(int, string) (resources.Task, v7action.Warnings, error) getTaskBySequenceIDAndApplicationMutex sync.RWMutex - getTaskBySequenceIDAndApplicationArgsForCall []struct { - arg1 int - arg2 string - } - getTaskBySequenceIDAndApplicationReturns struct { + getTaskBySequenceIDAndApplicationArgsForCall []FakeActorGetTaskBySequenceIDAndApplicationArgs + getTaskBySequenceIDAndApplicationReturns struct { result1 resources.Task result2 v7action.Warnings result3 error @@ -2574,9 +2157,8 @@ type FakeActor struct { } GetUAAAPIVersionStub func() (string, error) getUAAAPIVersionMutex sync.RWMutex - getUAAAPIVersionArgsForCall []struct { - } - getUAAAPIVersionReturns struct { + getUAAAPIVersionArgsForCall []struct{} + getUAAAPIVersionReturns struct { result1 string result2 error } @@ -2586,10 +2168,8 @@ type FakeActor struct { } GetUnstagedNewestPackageGUIDStub func(string) (string, v7action.Warnings, error) getUnstagedNewestPackageGUIDMutex sync.RWMutex - getUnstagedNewestPackageGUIDArgsForCall []struct { - arg1 string - } - getUnstagedNewestPackageGUIDReturns struct { + getUnstagedNewestPackageGUIDArgsForCall []FakeActorGetUnstagedNewestPackageGUIDArgs + getUnstagedNewestPackageGUIDReturns struct { result1 string result2 v7action.Warnings result3 error @@ -2601,11 +2181,8 @@ type FakeActor struct { } GetUserStub func(string, string) (resources.User, error) getUserMutex sync.RWMutex - getUserArgsForCall []struct { - arg1 string - arg2 string - } - getUserReturns struct { + getUserArgsForCall []FakeActorGetUserArgs + getUserReturns struct { result1 resources.User result2 error } @@ -2615,10 +2192,8 @@ type FakeActor struct { } ListAppBindingsStub func(v7action.ListAppBindingParams) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) listAppBindingsMutex sync.RWMutex - listAppBindingsArgsForCall []struct { - arg1 v7action.ListAppBindingParams - } - listAppBindingsReturns struct { + listAppBindingsArgsForCall []FakeActorListAppBindingsArgs + listAppBindingsReturns struct { result1 []resources.ServiceCredentialBinding result2 v7action.Warnings result3 error @@ -2630,10 +2205,8 @@ type FakeActor struct { } ListServiceAppBindingsStub func(v7action.ListServiceAppBindingParams) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) listServiceAppBindingsMutex sync.RWMutex - listServiceAppBindingsArgsForCall []struct { - arg1 v7action.ListServiceAppBindingParams - } - listServiceAppBindingsReturns struct { + listServiceAppBindingsArgsForCall []FakeActorListServiceAppBindingsArgs + listServiceAppBindingsReturns struct { result1 []resources.ServiceCredentialBinding result2 v7action.Warnings result3 error @@ -2645,14 +2218,8 @@ type FakeActor struct { } MakeCurlRequestStub func(string, string, []string, string, bool) ([]byte, *http.Response, error) makeCurlRequestMutex sync.RWMutex - makeCurlRequestArgsForCall []struct { - arg1 string - arg2 string - arg3 []string - arg4 string - arg5 bool - } - makeCurlRequestReturns struct { + makeCurlRequestArgsForCall []FakeActorMakeCurlRequestArgs + makeCurlRequestReturns struct { result1 []byte result2 *http.Response result3 error @@ -2664,13 +2231,8 @@ type FakeActor struct { } MapRouteStub func(string, string, string, int) (v7action.Warnings, error) mapRouteMutex sync.RWMutex - mapRouteArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 int - } - mapRouteReturns struct { + mapRouteArgsForCall []FakeActorMapRouteArgs + mapRouteReturns struct { result1 v7action.Warnings result2 error } @@ -2680,10 +2242,8 @@ type FakeActor struct { } MarketplaceStub func(v7action.MarketplaceFilter) ([]v7action.ServiceOfferingWithPlans, v7action.Warnings, error) marketplaceMutex sync.RWMutex - marketplaceArgsForCall []struct { - arg1 v7action.MarketplaceFilter - } - marketplaceReturns struct { + marketplaceArgsForCall []FakeActorMarketplaceArgs + marketplaceReturns struct { result1 []v7action.ServiceOfferingWithPlans result2 v7action.Warnings result3 error @@ -2695,11 +2255,8 @@ type FakeActor struct { } MoveRouteStub func(string, string) (v7action.Warnings, error) moveRouteMutex sync.RWMutex - moveRouteArgsForCall []struct { - arg1 string - arg2 string - } - moveRouteReturns struct { + moveRouteArgsForCall []FakeActorMoveRouteArgs + moveRouteReturns struct { result1 v7action.Warnings result2 error } @@ -2707,26 +2264,21 @@ type FakeActor struct { result1 v7action.Warnings result2 error } - ParseAccessTokenStub func(string) (jwtv5.MapClaims, error) + ParseAccessTokenStub func(string) (jwt.MapClaims, error) parseAccessTokenMutex sync.RWMutex - parseAccessTokenArgsForCall []struct { - arg1 string - } - parseAccessTokenReturns struct { - result1 jwtv5.MapClaims + parseAccessTokenArgsForCall []FakeActorParseAccessTokenArgs + parseAccessTokenReturns struct { + result1 jwt.MapClaims result2 error } parseAccessTokenReturnsOnCall map[int]struct { - result1 jwtv5.MapClaims + result1 jwt.MapClaims result2 error } PollBuildStub func(string, string) (resources.Droplet, v7action.Warnings, error) pollBuildMutex sync.RWMutex - pollBuildArgsForCall []struct { - arg1 string - arg2 string - } - pollBuildReturns struct { + pollBuildArgsForCall []FakeActorPollBuildArgs + pollBuildReturns struct { result1 resources.Droplet result2 v7action.Warnings result3 error @@ -2738,10 +2290,8 @@ type FakeActor struct { } PollPackageStub func(resources.Package) (resources.Package, v7action.Warnings, error) pollPackageMutex sync.RWMutex - pollPackageArgsForCall []struct { - arg1 resources.Package - } - pollPackageReturns struct { + pollPackageArgsForCall []FakeActorPollPackageArgs + pollPackageReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -2753,12 +2303,8 @@ type FakeActor struct { } PollStartStub func(resources.Application, bool, func(string)) (v7action.Warnings, error) pollStartMutex sync.RWMutex - pollStartArgsForCall []struct { - arg1 resources.Application - arg2 bool - arg3 func(string) - } - pollStartReturns struct { + pollStartArgsForCall []FakeActorPollStartArgs + pollStartReturns struct { result1 v7action.Warnings result2 error } @@ -2768,13 +2314,8 @@ type FakeActor struct { } PollStartForDeploymentStub func(resources.Application, string, bool, func(string)) (v7action.Warnings, error) pollStartForDeploymentMutex sync.RWMutex - pollStartForDeploymentArgsForCall []struct { - arg1 resources.Application - arg2 string - arg3 bool - arg4 func(string) - } - pollStartForDeploymentReturns struct { + pollStartForDeploymentArgsForCall []FakeActorPollStartForDeploymentArgs + pollStartForDeploymentReturns struct { result1 v7action.Warnings result2 error } @@ -2784,10 +2325,8 @@ type FakeActor struct { } PollTaskStub func(resources.Task) (resources.Task, v7action.Warnings, error) pollTaskMutex sync.RWMutex - pollTaskArgsForCall []struct { - arg1 resources.Task - } - pollTaskReturns struct { + pollTaskArgsForCall []FakeActorPollTaskArgs + pollTaskReturns struct { result1 resources.Task result2 v7action.Warnings result3 error @@ -2799,10 +2338,8 @@ type FakeActor struct { } PollUploadBuildpackJobStub func(ccv3.JobURL) (v7action.Warnings, error) pollUploadBuildpackJobMutex sync.RWMutex - pollUploadBuildpackJobArgsForCall []struct { - arg1 ccv3.JobURL - } - pollUploadBuildpackJobReturns struct { + pollUploadBuildpackJobArgsForCall []FakeActorPollUploadBuildpackJobArgs + pollUploadBuildpackJobReturns struct { result1 v7action.Warnings result2 error } @@ -2812,12 +2349,8 @@ type FakeActor struct { } PrepareBuildpackBitsStub func(string, string, v7action.Downloader) (string, error) prepareBuildpackBitsMutex sync.RWMutex - prepareBuildpackBitsArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.Downloader - } - prepareBuildpackBitsReturns struct { + prepareBuildpackBitsArgsForCall []FakeActorPrepareBuildpackBitsArgs + prepareBuildpackBitsReturns struct { result1 string result2 error } @@ -2827,11 +2360,8 @@ type FakeActor struct { } PurgeServiceInstanceStub func(string, string) (v7action.Warnings, error) purgeServiceInstanceMutex sync.RWMutex - purgeServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - } - purgeServiceInstanceReturns struct { + purgeServiceInstanceArgsForCall []FakeActorPurgeServiceInstanceArgs + purgeServiceInstanceReturns struct { result1 v7action.Warnings result2 error } @@ -2841,11 +2371,8 @@ type FakeActor struct { } PurgeServiceOfferingByNameAndBrokerStub func(string, string) (v7action.Warnings, error) purgeServiceOfferingByNameAndBrokerMutex sync.RWMutex - purgeServiceOfferingByNameAndBrokerArgsForCall []struct { - arg1 string - arg2 string - } - purgeServiceOfferingByNameAndBrokerReturns struct { + purgeServiceOfferingByNameAndBrokerArgsForCall []FakeActorPurgeServiceOfferingByNameAndBrokerArgs + purgeServiceOfferingByNameAndBrokerReturns struct { result1 v7action.Warnings result2 error } @@ -2855,9 +2382,8 @@ type FakeActor struct { } RefreshAccessTokenStub func() (string, error) refreshAccessTokenMutex sync.RWMutex - refreshAccessTokenArgsForCall []struct { - } - refreshAccessTokenReturns struct { + refreshAccessTokenArgsForCall []struct{} + refreshAccessTokenReturns struct { result1 string result2 error } @@ -2867,12 +2393,8 @@ type FakeActor struct { } RenameApplicationByNameAndSpaceGUIDStub func(string, string, string) (resources.Application, v7action.Warnings, error) renameApplicationByNameAndSpaceGUIDMutex sync.RWMutex - renameApplicationByNameAndSpaceGUIDArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - renameApplicationByNameAndSpaceGUIDReturns struct { + renameApplicationByNameAndSpaceGUIDArgsForCall []FakeActorRenameApplicationByNameAndSpaceGUIDArgs + renameApplicationByNameAndSpaceGUIDReturns struct { result1 resources.Application result2 v7action.Warnings result3 error @@ -2884,11 +2406,8 @@ type FakeActor struct { } RenameOrganizationStub func(string, string) (resources.Organization, v7action.Warnings, error) renameOrganizationMutex sync.RWMutex - renameOrganizationArgsForCall []struct { - arg1 string - arg2 string - } - renameOrganizationReturns struct { + renameOrganizationArgsForCall []FakeActorRenameOrganizationArgs + renameOrganizationReturns struct { result1 resources.Organization result2 v7action.Warnings result3 error @@ -2900,12 +2419,8 @@ type FakeActor struct { } RenameServiceInstanceStub func(string, string, string) (v7action.Warnings, error) renameServiceInstanceMutex sync.RWMutex - renameServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - renameServiceInstanceReturns struct { + renameServiceInstanceArgsForCall []FakeActorRenameServiceInstanceArgs + renameServiceInstanceReturns struct { result1 v7action.Warnings result2 error } @@ -2915,12 +2430,8 @@ type FakeActor struct { } RenameSpaceByNameAndOrganizationGUIDStub func(string, string, string) (resources.Space, v7action.Warnings, error) renameSpaceByNameAndOrganizationGUIDMutex sync.RWMutex - renameSpaceByNameAndOrganizationGUIDArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - renameSpaceByNameAndOrganizationGUIDReturns struct { + renameSpaceByNameAndOrganizationGUIDArgsForCall []FakeActorRenameSpaceByNameAndOrganizationGUIDArgs + renameSpaceByNameAndOrganizationGUIDReturns struct { result1 resources.Space result2 v7action.Warnings result3 error @@ -2932,10 +2443,8 @@ type FakeActor struct { } ResetOrganizationDefaultIsolationSegmentStub func(string) (v7action.Warnings, error) resetOrganizationDefaultIsolationSegmentMutex sync.RWMutex - resetOrganizationDefaultIsolationSegmentArgsForCall []struct { - arg1 string - } - resetOrganizationDefaultIsolationSegmentReturns struct { + resetOrganizationDefaultIsolationSegmentArgsForCall []FakeActorResetOrganizationDefaultIsolationSegmentArgs + resetOrganizationDefaultIsolationSegmentReturns struct { result1 v7action.Warnings result2 error } @@ -2945,11 +2454,8 @@ type FakeActor struct { } ResetSpaceIsolationSegmentStub func(string, string) (string, v7action.Warnings, error) resetSpaceIsolationSegmentMutex sync.RWMutex - resetSpaceIsolationSegmentArgsForCall []struct { - arg1 string - arg2 string - } - resetSpaceIsolationSegmentReturns struct { + resetSpaceIsolationSegmentArgsForCall []FakeActorResetSpaceIsolationSegmentArgs + resetSpaceIsolationSegmentReturns struct { result1 string result2 v7action.Warnings result3 error @@ -2961,10 +2467,8 @@ type FakeActor struct { } ResourceMatchStub func([]sharedaction.V3Resource) ([]sharedaction.V3Resource, v7action.Warnings, error) resourceMatchMutex sync.RWMutex - resourceMatchArgsForCall []struct { - arg1 []sharedaction.V3Resource - } - resourceMatchReturns struct { + resourceMatchArgsForCall []FakeActorResourceMatchArgs + resourceMatchReturns struct { result1 []sharedaction.V3Resource result2 v7action.Warnings result3 error @@ -2976,11 +2480,8 @@ type FakeActor struct { } RestartApplicationStub func(string, bool) (v7action.Warnings, error) restartApplicationMutex sync.RWMutex - restartApplicationArgsForCall []struct { - arg1 string - arg2 bool - } - restartApplicationReturns struct { + restartApplicationArgsForCall []FakeActorRestartApplicationArgs + restartApplicationReturns struct { result1 v7action.Warnings result2 error } @@ -2990,9 +2491,8 @@ type FakeActor struct { } RevokeAccessAndRefreshTokensStub func() error revokeAccessAndRefreshTokensMutex sync.RWMutex - revokeAccessAndRefreshTokensArgsForCall []struct { - } - revokeAccessAndRefreshTokensReturns struct { + revokeAccessAndRefreshTokensArgsForCall []struct{} + revokeAccessAndRefreshTokensReturns struct { result1 error } revokeAccessAndRefreshTokensReturnsOnCall map[int]struct { @@ -3000,11 +2500,8 @@ type FakeActor struct { } RunTaskStub func(string, resources.Task) (resources.Task, v7action.Warnings, error) runTaskMutex sync.RWMutex - runTaskArgsForCall []struct { - arg1 string - arg2 resources.Task - } - runTaskReturns struct { + runTaskArgsForCall []FakeActorRunTaskArgs + runTaskReturns struct { result1 resources.Task result2 v7action.Warnings result3 error @@ -3016,11 +2513,8 @@ type FakeActor struct { } ScaleProcessByApplicationStub func(string, resources.Process) (v7action.Warnings, error) scaleProcessByApplicationMutex sync.RWMutex - scaleProcessByApplicationArgsForCall []struct { - arg1 string - arg2 resources.Process - } - scaleProcessByApplicationReturns struct { + scaleProcessByApplicationArgsForCall []FakeActorScaleProcessByApplicationArgs + scaleProcessByApplicationReturns struct { result1 v7action.Warnings result2 error } @@ -3030,12 +2524,8 @@ type FakeActor struct { } ScheduleTokenRefreshStub func(func(time.Duration) <-chan time.Time, chan struct{}, chan struct{}) (<-chan error, error) scheduleTokenRefreshMutex sync.RWMutex - scheduleTokenRefreshArgsForCall []struct { - arg1 func(time.Duration) <-chan time.Time - arg2 chan struct{} - arg3 chan struct{} - } - scheduleTokenRefreshReturns struct { + scheduleTokenRefreshArgsForCall []FakeActorScheduleTokenRefreshArgs + scheduleTokenRefreshReturns struct { result1 <-chan error result2 error } @@ -3045,11 +2535,8 @@ type FakeActor struct { } SetApplicationDropletStub func(string, string) (v7action.Warnings, error) setApplicationDropletMutex sync.RWMutex - setApplicationDropletArgsForCall []struct { - arg1 string - arg2 string - } - setApplicationDropletReturns struct { + setApplicationDropletArgsForCall []FakeActorSetApplicationDropletArgs + setApplicationDropletReturns struct { result1 v7action.Warnings result2 error } @@ -3059,12 +2546,8 @@ type FakeActor struct { } SetApplicationDropletByApplicationNameAndSpaceStub func(string, string, string) (v7action.Warnings, error) setApplicationDropletByApplicationNameAndSpaceMutex sync.RWMutex - setApplicationDropletByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - setApplicationDropletByApplicationNameAndSpaceReturns struct { + setApplicationDropletByApplicationNameAndSpaceArgsForCall []FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs + setApplicationDropletByApplicationNameAndSpaceReturns struct { result1 v7action.Warnings result2 error } @@ -3074,11 +2557,8 @@ type FakeActor struct { } SetApplicationManifestStub func(string, []byte) (v7action.Warnings, error) setApplicationManifestMutex sync.RWMutex - setApplicationManifestArgsForCall []struct { - arg1 string - arg2 []byte - } - setApplicationManifestReturns struct { + setApplicationManifestArgsForCall []FakeActorSetApplicationManifestArgs + setApplicationManifestReturns struct { result1 v7action.Warnings result2 error } @@ -3088,15 +2568,8 @@ type FakeActor struct { } SetApplicationProcessHealthCheckTypeByNameAndSpaceStub func(string, string, constanta.HealthCheckType, string, string, int64) (resources.Application, v7action.Warnings, error) setApplicationProcessHealthCheckTypeByNameAndSpaceMutex sync.RWMutex - setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 constanta.HealthCheckType - arg4 string - arg5 string - arg6 int64 - } - setApplicationProcessHealthCheckTypeByNameAndSpaceReturns struct { + setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall []FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs + setApplicationProcessHealthCheckTypeByNameAndSpaceReturns struct { result1 resources.Application result2 v7action.Warnings result3 error @@ -3108,12 +2581,8 @@ type FakeActor struct { } SetEnvironmentVariableByApplicationNameAndSpaceStub func(string, string, v7action.EnvironmentVariablePair) (v7action.Warnings, error) setEnvironmentVariableByApplicationNameAndSpaceMutex sync.RWMutex - setEnvironmentVariableByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.EnvironmentVariablePair - } - setEnvironmentVariableByApplicationNameAndSpaceReturns struct { + setEnvironmentVariableByApplicationNameAndSpaceArgsForCall []FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs + setEnvironmentVariableByApplicationNameAndSpaceReturns struct { result1 v7action.Warnings result2 error } @@ -3123,11 +2592,8 @@ type FakeActor struct { } SetEnvironmentVariableGroupStub func(constanta.EnvironmentVariableGroupName, resources.EnvironmentVariables) (v7action.Warnings, error) setEnvironmentVariableGroupMutex sync.RWMutex - setEnvironmentVariableGroupArgsForCall []struct { - arg1 constanta.EnvironmentVariableGroupName - arg2 resources.EnvironmentVariables - } - setEnvironmentVariableGroupReturns struct { + setEnvironmentVariableGroupArgsForCall []FakeActorSetEnvironmentVariableGroupArgs + setEnvironmentVariableGroupReturns struct { result1 v7action.Warnings result2 error } @@ -3137,11 +2603,8 @@ type FakeActor struct { } SetOrganizationDefaultIsolationSegmentStub func(string, string) (v7action.Warnings, error) setOrganizationDefaultIsolationSegmentMutex sync.RWMutex - setOrganizationDefaultIsolationSegmentArgsForCall []struct { - arg1 string - arg2 string - } - setOrganizationDefaultIsolationSegmentReturns struct { + setOrganizationDefaultIsolationSegmentArgsForCall []FakeActorSetOrganizationDefaultIsolationSegmentArgs + setOrganizationDefaultIsolationSegmentReturns struct { result1 v7action.Warnings result2 error } @@ -3149,13 +2612,21 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + SetServiceAccountEnabledByNameAndSpaceStub func(string, string, bool) (v7action.Warnings, error) + setServiceAccountEnabledByNameAndSpaceMutex sync.RWMutex + setServiceAccountEnabledByNameAndSpaceArgsForCall []FakeActorSetServiceAccountEnabledByNameAndSpaceArgs + setServiceAccountEnabledByNameAndSpaceReturns struct { + result1 v7action.Warnings + result2 error + } + setServiceAccountEnabledByNameAndSpaceReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } SetSpaceManifestStub func(string, []byte) (v7action.Warnings, error) setSpaceManifestMutex sync.RWMutex - setSpaceManifestArgsForCall []struct { - arg1 string - arg2 []byte - } - setSpaceManifestReturns struct { + setSpaceManifestArgsForCall []FakeActorSetSpaceManifestArgs + setSpaceManifestReturns struct { result1 v7action.Warnings result2 error } @@ -3165,10 +2636,8 @@ type FakeActor struct { } SetTargetStub func(v7action.TargetSettings) (v7action.Warnings, error) setTargetMutex sync.RWMutex - setTargetArgsForCall []struct { - arg1 v7action.TargetSettings - } - setTargetReturns struct { + setTargetArgsForCall []FakeActorSetTargetArgs + setTargetReturns struct { result1 v7action.Warnings result2 error } @@ -3178,11 +2647,8 @@ type FakeActor struct { } SharePrivateDomainStub func(string, string) (v7action.Warnings, error) sharePrivateDomainMutex sync.RWMutex - sharePrivateDomainArgsForCall []struct { - arg1 string - arg2 string - } - sharePrivateDomainReturns struct { + sharePrivateDomainArgsForCall []FakeActorSharePrivateDomainArgs + sharePrivateDomainReturns struct { result1 v7action.Warnings result2 error } @@ -3192,11 +2658,8 @@ type FakeActor struct { } ShareRouteStub func(string, string) (v7action.Warnings, error) shareRouteMutex sync.RWMutex - shareRouteArgsForCall []struct { - arg1 string - arg2 string - } - shareRouteReturns struct { + shareRouteArgsForCall []FakeActorShareRouteArgs + shareRouteReturns struct { result1 v7action.Warnings result2 error } @@ -3206,13 +2669,8 @@ type FakeActor struct { } ShareServiceInstanceToSpaceAndOrgStub func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) shareServiceInstanceToSpaceAndOrgMutex sync.RWMutex - shareServiceInstanceToSpaceAndOrgArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.ServiceInstanceSharingParams - } - shareServiceInstanceToSpaceAndOrgReturns struct { + shareServiceInstanceToSpaceAndOrgArgsForCall []FakeActorShareServiceInstanceToSpaceAndOrgArgs + shareServiceInstanceToSpaceAndOrgReturns struct { result1 v7action.Warnings result2 error } @@ -3222,10 +2680,8 @@ type FakeActor struct { } StageApplicationPackageStub func(string) (resources.Build, v7action.Warnings, error) stageApplicationPackageMutex sync.RWMutex - stageApplicationPackageArgsForCall []struct { - arg1 string - } - stageApplicationPackageReturns struct { + stageApplicationPackageArgsForCall []FakeActorStageApplicationPackageArgs + stageApplicationPackageReturns struct { result1 resources.Build result2 v7action.Warnings result3 error @@ -3237,12 +2693,8 @@ type FakeActor struct { } StagePackageStub func(string, string, string) (<-chan resources.Droplet, <-chan v7action.Warnings, <-chan error) stagePackageMutex sync.RWMutex - stagePackageArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - stagePackageReturns struct { + stagePackageArgsForCall []FakeActorStagePackageArgs + stagePackageReturns struct { result1 <-chan resources.Droplet result2 <-chan v7action.Warnings result3 <-chan error @@ -3254,10 +2706,8 @@ type FakeActor struct { } StartApplicationStub func(string) (v7action.Warnings, error) startApplicationMutex sync.RWMutex - startApplicationArgsForCall []struct { - arg1 string - } - startApplicationReturns struct { + startApplicationArgsForCall []FakeActorStartApplicationArgs + startApplicationReturns struct { result1 v7action.Warnings result2 error } @@ -3267,10 +2717,8 @@ type FakeActor struct { } StopApplicationStub func(string) (v7action.Warnings, error) stopApplicationMutex sync.RWMutex - stopApplicationArgsForCall []struct { - arg1 string - } - stopApplicationReturns struct { + stopApplicationArgsForCall []FakeActorStopApplicationArgs + stopApplicationReturns struct { result1 v7action.Warnings result2 error } @@ -3280,10 +2728,8 @@ type FakeActor struct { } TerminateTaskStub func(string) (resources.Task, v7action.Warnings, error) terminateTaskMutex sync.RWMutex - terminateTaskArgsForCall []struct { - arg1 string - } - terminateTaskReturns struct { + terminateTaskArgsForCall []FakeActorTerminateTaskArgs + terminateTaskReturns struct { result1 resources.Task result2 v7action.Warnings result3 error @@ -3295,13 +2741,8 @@ type FakeActor struct { } UnbindSecurityGroupStub func(string, string, string, constanta.SecurityGroupLifecycle) (v7action.Warnings, error) unbindSecurityGroupMutex sync.RWMutex - unbindSecurityGroupArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 constanta.SecurityGroupLifecycle - } - unbindSecurityGroupReturns struct { + unbindSecurityGroupArgsForCall []FakeActorUnbindSecurityGroupArgs + unbindSecurityGroupReturns struct { result1 v7action.Warnings result2 error } @@ -3309,13 +2750,21 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + UnbindServiceAccountByAppNameAndSpaceStub func(string, string) (v7action.Warnings, error) + unbindServiceAccountByAppNameAndSpaceMutex sync.RWMutex + unbindServiceAccountByAppNameAndSpaceArgsForCall []FakeActorUnbindServiceAccountByAppNameAndSpaceArgs + unbindServiceAccountByAppNameAndSpaceReturns struct { + result1 v7action.Warnings + result2 error + } + unbindServiceAccountByAppNameAndSpaceReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } UnmapRouteStub func(string, string) (v7action.Warnings, error) unmapRouteMutex sync.RWMutex - unmapRouteArgsForCall []struct { - arg1 string - arg2 string - } - unmapRouteReturns struct { + unmapRouteArgsForCall []FakeActorUnmapRouteArgs + unmapRouteReturns struct { result1 v7action.Warnings result2 error } @@ -3325,12 +2774,8 @@ type FakeActor struct { } UnsetEnvironmentVariableByApplicationNameAndSpaceStub func(string, string, string) (v7action.Warnings, error) unsetEnvironmentVariableByApplicationNameAndSpaceMutex sync.RWMutex - unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - unsetEnvironmentVariableByApplicationNameAndSpaceReturns struct { + unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall []FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs + unsetEnvironmentVariableByApplicationNameAndSpaceReturns struct { result1 v7action.Warnings result2 error } @@ -3340,12 +2785,8 @@ type FakeActor struct { } UnsetSpaceQuotaStub func(string, string, string) (v7action.Warnings, error) unsetSpaceQuotaMutex sync.RWMutex - unsetSpaceQuotaArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - unsetSpaceQuotaReturns struct { + unsetSpaceQuotaArgsForCall []FakeActorUnsetSpaceQuotaArgs + unsetSpaceQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -3355,11 +2796,8 @@ type FakeActor struct { } UnsharePrivateDomainStub func(string, string) (v7action.Warnings, error) unsharePrivateDomainMutex sync.RWMutex - unsharePrivateDomainArgsForCall []struct { - arg1 string - arg2 string - } - unsharePrivateDomainReturns struct { + unsharePrivateDomainArgsForCall []FakeActorUnsharePrivateDomainArgs + unsharePrivateDomainReturns struct { result1 v7action.Warnings result2 error } @@ -3369,11 +2807,8 @@ type FakeActor struct { } UnshareRouteStub func(string, string) (v7action.Warnings, error) unshareRouteMutex sync.RWMutex - unshareRouteArgsForCall []struct { - arg1 string - arg2 string - } - unshareRouteReturns struct { + unshareRouteArgsForCall []FakeActorUnshareRouteArgs + unshareRouteReturns struct { result1 v7action.Warnings result2 error } @@ -3383,13 +2818,8 @@ type FakeActor struct { } UnshareServiceInstanceFromSpaceAndOrgStub func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) unshareServiceInstanceFromSpaceAndOrgMutex sync.RWMutex - unshareServiceInstanceFromSpaceAndOrgArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.ServiceInstanceSharingParams - } - unshareServiceInstanceFromSpaceAndOrgReturns struct { + unshareServiceInstanceFromSpaceAndOrgArgsForCall []FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs + unshareServiceInstanceFromSpaceAndOrgReturns struct { result1 v7action.Warnings result2 error } @@ -3399,12 +2829,8 @@ type FakeActor struct { } UpdateAppFeatureStub func(resources.Application, bool, string) (v7action.Warnings, error) updateAppFeatureMutex sync.RWMutex - updateAppFeatureArgsForCall []struct { - arg1 resources.Application - arg2 bool - arg3 string - } - updateAppFeatureReturns struct { + updateAppFeatureArgsForCall []FakeActorUpdateAppFeatureArgs + updateAppFeatureReturns struct { result1 v7action.Warnings result2 error } @@ -3414,10 +2840,8 @@ type FakeActor struct { } UpdateApplicationStub func(resources.Application) (resources.Application, v7action.Warnings, error) updateApplicationMutex sync.RWMutex - updateApplicationArgsForCall []struct { - arg1 resources.Application - } - updateApplicationReturns struct { + updateApplicationArgsForCall []FakeActorUpdateApplicationArgs + updateApplicationReturns struct { result1 resources.Application result2 v7action.Warnings result3 error @@ -3429,12 +2853,8 @@ type FakeActor struct { } UpdateApplicationLabelsByApplicationNameStub func(string, string, map[string]types.NullString) (v7action.Warnings, error) updateApplicationLabelsByApplicationNameMutex sync.RWMutex - updateApplicationLabelsByApplicationNameArgsForCall []struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - } - updateApplicationLabelsByApplicationNameReturns struct { + updateApplicationLabelsByApplicationNameArgsForCall []FakeActorUpdateApplicationLabelsByApplicationNameArgs + updateApplicationLabelsByApplicationNameReturns struct { result1 v7action.Warnings result2 error } @@ -3444,13 +2864,8 @@ type FakeActor struct { } UpdateBuildpackByNameAndStackAndLifecycleStub func(string, string, string, resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) updateBuildpackByNameAndStackAndLifecycleMutex sync.RWMutex - updateBuildpackByNameAndStackAndLifecycleArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 resources.Buildpack - } - updateBuildpackByNameAndStackAndLifecycleReturns struct { + updateBuildpackByNameAndStackAndLifecycleArgsForCall []FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs + updateBuildpackByNameAndStackAndLifecycleReturns struct { result1 resources.Buildpack result2 v7action.Warnings result3 error @@ -3462,13 +2877,8 @@ type FakeActor struct { } UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub func(string, string, string, map[string]types.NullString) (v7action.Warnings, error) updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex sync.RWMutex - updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - } - updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns struct { + updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall []FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs + updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns struct { result1 v7action.Warnings result2 error } @@ -3478,12 +2888,8 @@ type FakeActor struct { } UpdateDestinationStub func(string, string, string) (v7action.Warnings, error) updateDestinationMutex sync.RWMutex - updateDestinationArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - updateDestinationReturns struct { + updateDestinationArgsForCall []FakeActorUpdateDestinationArgs + updateDestinationReturns struct { result1 v7action.Warnings result2 error } @@ -3493,11 +2899,8 @@ type FakeActor struct { } UpdateDomainLabelsByDomainNameStub func(string, map[string]types.NullString) (v7action.Warnings, error) updateDomainLabelsByDomainNameMutex sync.RWMutex - updateDomainLabelsByDomainNameArgsForCall []struct { - arg1 string - arg2 map[string]types.NullString - } - updateDomainLabelsByDomainNameReturns struct { + updateDomainLabelsByDomainNameArgsForCall []FakeActorUpdateDomainLabelsByDomainNameArgs + updateDomainLabelsByDomainNameReturns struct { result1 v7action.Warnings result2 error } @@ -3507,10 +2910,8 @@ type FakeActor struct { } UpdateManagedServiceInstanceStub func(v7action.UpdateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) updateManagedServiceInstanceMutex sync.RWMutex - updateManagedServiceInstanceArgsForCall []struct { - arg1 v7action.UpdateManagedServiceInstanceParams - } - updateManagedServiceInstanceReturns struct { + updateManagedServiceInstanceArgsForCall []FakeActorUpdateManagedServiceInstanceArgs + updateManagedServiceInstanceReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -3522,11 +2923,8 @@ type FakeActor struct { } UpdateOrganizationLabelsByOrganizationNameStub func(string, map[string]types.NullString) (v7action.Warnings, error) updateOrganizationLabelsByOrganizationNameMutex sync.RWMutex - updateOrganizationLabelsByOrganizationNameArgsForCall []struct { - arg1 string - arg2 map[string]types.NullString - } - updateOrganizationLabelsByOrganizationNameReturns struct { + updateOrganizationLabelsByOrganizationNameArgsForCall []FakeActorUpdateOrganizationLabelsByOrganizationNameArgs + updateOrganizationLabelsByOrganizationNameReturns struct { result1 v7action.Warnings result2 error } @@ -3536,12 +2934,8 @@ type FakeActor struct { } UpdateOrganizationQuotaStub func(string, string, v7action.QuotaLimits) (v7action.Warnings, error) updateOrganizationQuotaMutex sync.RWMutex - updateOrganizationQuotaArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.QuotaLimits - } - updateOrganizationQuotaReturns struct { + updateOrganizationQuotaArgsForCall []FakeActorUpdateOrganizationQuotaArgs + updateOrganizationQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -3551,12 +2945,8 @@ type FakeActor struct { } UpdateProcessByTypeAndApplicationStub func(string, string, resources.Process) (v7action.Warnings, error) updateProcessByTypeAndApplicationMutex sync.RWMutex - updateProcessByTypeAndApplicationArgsForCall []struct { - arg1 string - arg2 string - arg3 resources.Process - } - updateProcessByTypeAndApplicationReturns struct { + updateProcessByTypeAndApplicationArgsForCall []FakeActorUpdateProcessByTypeAndApplicationArgs + updateProcessByTypeAndApplicationReturns struct { result1 v7action.Warnings result2 error } @@ -3566,11 +2956,8 @@ type FakeActor struct { } UpdateRouteStub func(string, map[string]*string) (resources.Route, v7action.Warnings, error) updateRouteMutex sync.RWMutex - updateRouteArgsForCall []struct { - arg1 string - arg2 map[string]*string - } - updateRouteReturns struct { + updateRouteArgsForCall []FakeActorUpdateRouteArgs + updateRouteReturns struct { result1 resources.Route result2 v7action.Warnings result3 error @@ -3582,12 +2969,8 @@ type FakeActor struct { } UpdateRouteLabelsStub func(string, string, map[string]types.NullString) (v7action.Warnings, error) updateRouteLabelsMutex sync.RWMutex - updateRouteLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - } - updateRouteLabelsReturns struct { + updateRouteLabelsArgsForCall []FakeActorUpdateRouteLabelsArgs + updateRouteLabelsReturns struct { result1 v7action.Warnings result2 error } @@ -3597,13 +2980,8 @@ type FakeActor struct { } UpdateRoutePolicyLabelsStub func(string, string, string, map[string]types.NullString) (v7action.Warnings, error) updateRoutePolicyLabelsMutex sync.RWMutex - updateRoutePolicyLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - } - updateRoutePolicyLabelsReturns struct { + updateRoutePolicyLabelsArgsForCall []FakeActorUpdateRoutePolicyLabelsArgs + updateRoutePolicyLabelsReturns struct { result1 v7action.Warnings result2 error } @@ -3613,11 +2991,8 @@ type FakeActor struct { } UpdateSecurityGroupStub func(string, string) (v7action.Warnings, error) updateSecurityGroupMutex sync.RWMutex - updateSecurityGroupArgsForCall []struct { - arg1 string - arg2 string - } - updateSecurityGroupReturns struct { + updateSecurityGroupArgsForCall []FakeActorUpdateSecurityGroupArgs + updateSecurityGroupReturns struct { result1 v7action.Warnings result2 error } @@ -3627,12 +3002,8 @@ type FakeActor struct { } UpdateSecurityGroupGloballyEnabledStub func(string, constanta.SecurityGroupLifecycle, bool) (v7action.Warnings, error) updateSecurityGroupGloballyEnabledMutex sync.RWMutex - updateSecurityGroupGloballyEnabledArgsForCall []struct { - arg1 string - arg2 constanta.SecurityGroupLifecycle - arg3 bool - } - updateSecurityGroupGloballyEnabledReturns struct { + updateSecurityGroupGloballyEnabledArgsForCall []FakeActorUpdateSecurityGroupGloballyEnabledArgs + updateSecurityGroupGloballyEnabledReturns struct { result1 v7action.Warnings result2 error } @@ -3642,11 +3013,8 @@ type FakeActor struct { } UpdateServiceBrokerStub func(string, resources.ServiceBroker) (v7action.Warnings, error) updateServiceBrokerMutex sync.RWMutex - updateServiceBrokerArgsForCall []struct { - arg1 string - arg2 resources.ServiceBroker - } - updateServiceBrokerReturns struct { + updateServiceBrokerArgsForCall []FakeActorUpdateServiceBrokerArgs + updateServiceBrokerReturns struct { result1 v7action.Warnings result2 error } @@ -3656,11 +3024,8 @@ type FakeActor struct { } UpdateServiceBrokerLabelsByServiceBrokerNameStub func(string, map[string]types.NullString) (v7action.Warnings, error) updateServiceBrokerLabelsByServiceBrokerNameMutex sync.RWMutex - updateServiceBrokerLabelsByServiceBrokerNameArgsForCall []struct { - arg1 string - arg2 map[string]types.NullString - } - updateServiceBrokerLabelsByServiceBrokerNameReturns struct { + updateServiceBrokerLabelsByServiceBrokerNameArgsForCall []FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs + updateServiceBrokerLabelsByServiceBrokerNameReturns struct { result1 v7action.Warnings result2 error } @@ -3670,12 +3035,8 @@ type FakeActor struct { } UpdateServiceInstanceLabelsStub func(string, string, map[string]types.NullString) (v7action.Warnings, error) updateServiceInstanceLabelsMutex sync.RWMutex - updateServiceInstanceLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - } - updateServiceInstanceLabelsReturns struct { + updateServiceInstanceLabelsArgsForCall []FakeActorUpdateServiceInstanceLabelsArgs + updateServiceInstanceLabelsReturns struct { result1 v7action.Warnings result2 error } @@ -3685,12 +3046,8 @@ type FakeActor struct { } UpdateServiceOfferingLabelsStub func(string, string, map[string]types.NullString) (v7action.Warnings, error) updateServiceOfferingLabelsMutex sync.RWMutex - updateServiceOfferingLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - } - updateServiceOfferingLabelsReturns struct { + updateServiceOfferingLabelsArgsForCall []FakeActorUpdateServiceOfferingLabelsArgs + updateServiceOfferingLabelsReturns struct { result1 v7action.Warnings result2 error } @@ -3700,13 +3057,8 @@ type FakeActor struct { } UpdateServicePlanLabelsStub func(string, string, string, map[string]types.NullString) (v7action.Warnings, error) updateServicePlanLabelsMutex sync.RWMutex - updateServicePlanLabelsArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - } - updateServicePlanLabelsReturns struct { + updateServicePlanLabelsArgsForCall []FakeActorUpdateServicePlanLabelsArgs + updateServicePlanLabelsReturns struct { result1 v7action.Warnings result2 error } @@ -3716,13 +3068,8 @@ type FakeActor struct { } UpdateSpaceFeatureStub func(string, string, bool, string) (v7action.Warnings, error) updateSpaceFeatureMutex sync.RWMutex - updateSpaceFeatureArgsForCall []struct { - arg1 string - arg2 string - arg3 bool - arg4 string - } - updateSpaceFeatureReturns struct { + updateSpaceFeatureArgsForCall []FakeActorUpdateSpaceFeatureArgs + updateSpaceFeatureReturns struct { result1 v7action.Warnings result2 error } @@ -3732,12 +3079,8 @@ type FakeActor struct { } UpdateSpaceLabelsBySpaceNameStub func(string, string, map[string]types.NullString) (v7action.Warnings, error) updateSpaceLabelsBySpaceNameMutex sync.RWMutex - updateSpaceLabelsBySpaceNameArgsForCall []struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - } - updateSpaceLabelsBySpaceNameReturns struct { + updateSpaceLabelsBySpaceNameArgsForCall []FakeActorUpdateSpaceLabelsBySpaceNameArgs + updateSpaceLabelsBySpaceNameReturns struct { result1 v7action.Warnings result2 error } @@ -3747,13 +3090,8 @@ type FakeActor struct { } UpdateSpaceQuotaStub func(string, string, string, v7action.QuotaLimits) (v7action.Warnings, error) updateSpaceQuotaMutex sync.RWMutex - updateSpaceQuotaArgsForCall []struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.QuotaLimits - } - updateSpaceQuotaReturns struct { + updateSpaceQuotaArgsForCall []FakeActorUpdateSpaceQuotaArgs + updateSpaceQuotaReturns struct { result1 v7action.Warnings result2 error } @@ -3763,12 +3101,8 @@ type FakeActor struct { } UpdateStackStub func(string, string, string) (resources.Stack, v7action.Warnings, error) updateStackMutex sync.RWMutex - updateStackArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - updateStackReturns struct { + updateStackArgsForCall []FakeActorUpdateStackArgs + updateStackReturns struct { result1 resources.Stack result2 v7action.Warnings result3 error @@ -3780,11 +3114,8 @@ type FakeActor struct { } UpdateStackLabelsByStackNameStub func(string, map[string]types.NullString) (v7action.Warnings, error) updateStackLabelsByStackNameMutex sync.RWMutex - updateStackLabelsByStackNameArgsForCall []struct { - arg1 string - arg2 map[string]types.NullString - } - updateStackLabelsByStackNameReturns struct { + updateStackLabelsByStackNameArgsForCall []FakeActorUpdateStackLabelsByStackNameArgs + updateStackLabelsByStackNameReturns struct { result1 v7action.Warnings result2 error } @@ -3794,12 +3125,8 @@ type FakeActor struct { } UpdateUserPasswordStub func(string, string, string) error updateUserPasswordMutex sync.RWMutex - updateUserPasswordArgsForCall []struct { - arg1 string - arg2 string - arg3 string - } - updateUserPasswordReturns struct { + updateUserPasswordArgsForCall []FakeActorUpdateUserPasswordArgs + updateUserPasswordReturns struct { result1 error } updateUserPasswordReturnsOnCall map[int]struct { @@ -3807,12 +3134,8 @@ type FakeActor struct { } UpdateUserProvidedServiceInstanceStub func(string, string, resources.ServiceInstance) (v7action.Warnings, error) updateUserProvidedServiceInstanceMutex sync.RWMutex - updateUserProvidedServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - arg3 resources.ServiceInstance - } - updateUserProvidedServiceInstanceReturns struct { + updateUserProvidedServiceInstanceArgsForCall []FakeActorUpdateUserProvidedServiceInstanceArgs + updateUserProvidedServiceInstanceReturns struct { result1 v7action.Warnings result2 error } @@ -3822,11 +3145,8 @@ type FakeActor struct { } UpgradeManagedServiceInstanceStub func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error) upgradeManagedServiceInstanceMutex sync.RWMutex - upgradeManagedServiceInstanceArgsForCall []struct { - arg1 string - arg2 string - } - upgradeManagedServiceInstanceReturns struct { + upgradeManagedServiceInstanceArgsForCall []FakeActorUpgradeManagedServiceInstanceArgs + upgradeManagedServiceInstanceReturns struct { result1 chan v7action.PollJobEvent result2 v7action.Warnings result3 error @@ -3838,13 +3158,8 @@ type FakeActor struct { } UploadBitsPackageStub func(resources.Package, []sharedaction.V3Resource, io.Reader, int64) (resources.Package, v7action.Warnings, error) uploadBitsPackageMutex sync.RWMutex - uploadBitsPackageArgsForCall []struct { - arg1 resources.Package - arg2 []sharedaction.V3Resource - arg3 io.Reader - arg4 int64 - } - uploadBitsPackageReturns struct { + uploadBitsPackageArgsForCall []FakeActorUploadBitsPackageArgs + uploadBitsPackageReturns struct { result1 resources.Package result2 v7action.Warnings result3 error @@ -3856,12 +3171,8 @@ type FakeActor struct { } UploadBuildpackStub func(string, string, v7action.SimpleProgressBar) (ccv3.JobURL, v7action.Warnings, error) uploadBuildpackMutex sync.RWMutex - uploadBuildpackArgsForCall []struct { - arg1 string - arg2 string - arg3 v7action.SimpleProgressBar - } - uploadBuildpackReturns struct { + uploadBuildpackArgsForCall []FakeActorUploadBuildpackArgs + uploadBuildpackReturns struct { result1 ccv3.JobURL result2 v7action.Warnings result3 error @@ -3873,13 +3184,8 @@ type FakeActor struct { } UploadDropletStub func(string, string, io.Reader, int64) (v7action.Warnings, error) uploadDropletMutex sync.RWMutex - uploadDropletArgsForCall []struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - } - uploadDropletReturns struct { + uploadDropletArgsForCall []FakeActorUploadDropletArgs + uploadDropletReturns struct { result1 v7action.Warnings result2 error } @@ -3888,18 +3194,1529 @@ type FakeActor struct { result2 error } invocations map[string][][]interface{} + callOrder []string invocationsMutex sync.RWMutex } +// FakeActorAddRoutePolicyArgs holds the arguments of one call to AddRoutePolicy. +type FakeActorAddRoutePolicyArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string +} + +// FakeActorApplyOrganizationQuotaByNameArgs holds the arguments of one call to ApplyOrganizationQuotaByName. +type FakeActorApplyOrganizationQuotaByNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorApplySpaceQuotaByNameArgs holds the arguments of one call to ApplySpaceQuotaByName. +type FakeActorApplySpaceQuotaByNameArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs holds the arguments of one call to AssignIsolationSegmentToSpaceByNameAndSpace. +type FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorAuthenticateArgs holds the arguments of one call to Authenticate. +type FakeActorAuthenticateArgs struct { + Arg1 map[string]string + Arg2 string + Arg3 constant.GrantType +} + +// FakeActorBindSecurityGroupToSpacesArgs holds the arguments of one call to BindSecurityGroupToSpaces. +type FakeActorBindSecurityGroupToSpacesArgs struct { + Arg1 string + Arg2 []resources.Space + Arg3 constanta.SecurityGroupLifecycle +} + +// FakeActorBindServiceAccountByNameAndSpaceArgs holds the arguments of one call to BindServiceAccountByNameAndSpace. +type FakeActorBindServiceAccountByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorCancelDeploymentArgs holds the arguments of one call to CancelDeployment. +type FakeActorCancelDeploymentArgs struct { + Arg1 string +} + +// FakeActorCheckRouteArgs holds the arguments of one call to CheckRoute. +type FakeActorCheckRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeActorContinueDeploymentArgs holds the arguments of one call to ContinueDeployment. +type FakeActorContinueDeploymentArgs struct { + Arg1 string +} + +// FakeActorCopyPackageArgs holds the arguments of one call to CopyPackage. +type FakeActorCopyPackageArgs struct { + Arg1 resources.Application + Arg2 resources.Application +} + +// FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs holds the arguments of one call to CreateAndUploadBitsPackageByApplicationNameAndSpace. +type FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorCreateApplicationDropletArgs holds the arguments of one call to CreateApplicationDroplet. +type FakeActorCreateApplicationDropletArgs struct { + Arg1 string +} + +// FakeActorCreateApplicationInSpaceArgs holds the arguments of one call to CreateApplicationInSpace. +type FakeActorCreateApplicationInSpaceArgs struct { + Arg1 resources.Application + Arg2 string +} + +// FakeActorCreateBitsPackageByApplicationArgs holds the arguments of one call to CreateBitsPackageByApplication. +type FakeActorCreateBitsPackageByApplicationArgs struct { + Arg1 string +} + +// FakeActorCreateBuildpackArgs holds the arguments of one call to CreateBuildpack. +type FakeActorCreateBuildpackArgs struct { + Arg1 resources.Buildpack +} + +// FakeActorCreateDeploymentArgs holds the arguments of one call to CreateDeployment. +type FakeActorCreateDeploymentArgs struct { + Arg1 resources.Deployment +} + +// FakeActorCreateDockerPackageByApplicationArgs holds the arguments of one call to CreateDockerPackageByApplication. +type FakeActorCreateDockerPackageByApplicationArgs struct { + Arg1 string + Arg2 v7action.DockerImageCredentials +} + +// FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs holds the arguments of one call to CreateDockerPackageByApplicationNameAndSpace. +type FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.DockerImageCredentials +} + +// FakeActorCreateIsolationSegmentByNameArgs holds the arguments of one call to CreateIsolationSegmentByName. +type FakeActorCreateIsolationSegmentByNameArgs struct { + Arg1 resources.IsolationSegment +} + +// FakeActorCreateManagedServiceInstanceArgs holds the arguments of one call to CreateManagedServiceInstance. +type FakeActorCreateManagedServiceInstanceArgs struct { + Arg1 v7action.CreateManagedServiceInstanceParams +} + +// FakeActorCreateOrgRoleArgs holds the arguments of one call to CreateOrgRole. +type FakeActorCreateOrgRoleArgs struct { + Arg1 constanta.RoleType + Arg2 string + Arg3 string + Arg4 string + Arg5 bool +} + +// FakeActorCreateOrganizationArgs holds the arguments of one call to CreateOrganization. +type FakeActorCreateOrganizationArgs struct { + Arg1 string +} + +// FakeActorCreateOrganizationQuotaArgs holds the arguments of one call to CreateOrganizationQuota. +type FakeActorCreateOrganizationQuotaArgs struct { + Arg1 string + Arg2 v7action.QuotaLimits +} + +// FakeActorCreatePrivateDomainArgs holds the arguments of one call to CreatePrivateDomain. +type FakeActorCreatePrivateDomainArgs struct { + Arg1 string + Arg2 string + Arg3 bool + Arg4 string +} + +// FakeActorCreateRouteArgs holds the arguments of one call to CreateRoute. +type FakeActorCreateRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string + Arg5 int + Arg6 map[string]*string +} + +// FakeActorCreateRouteBindingArgs holds the arguments of one call to CreateRouteBinding. +type FakeActorCreateRouteBindingArgs struct { + Arg1 v7action.CreateRouteBindingParams +} + +// FakeActorCreateSecurityGroupArgs holds the arguments of one call to CreateSecurityGroup. +type FakeActorCreateSecurityGroupArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorCreateServiceAccountInSpaceArgs holds the arguments of one call to CreateServiceAccountInSpace. +type FakeActorCreateServiceAccountInSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorCreateServiceAppBindingArgs holds the arguments of one call to CreateServiceAppBinding. +type FakeActorCreateServiceAppBindingArgs struct { + Arg1 v7action.CreateServiceAppBindingParams +} + +// FakeActorCreateServiceBrokerArgs holds the arguments of one call to CreateServiceBroker. +type FakeActorCreateServiceBrokerArgs struct { + Arg1 resources.ServiceBroker +} + +// FakeActorCreateServiceKeyArgs holds the arguments of one call to CreateServiceKey. +type FakeActorCreateServiceKeyArgs struct { + Arg1 v7action.CreateServiceKeyParams +} + +// FakeActorCreateSharedDomainArgs holds the arguments of one call to CreateSharedDomain. +type FakeActorCreateSharedDomainArgs struct { + Arg1 string + Arg2 bool + Arg3 string + Arg4 bool + Arg5 string +} + +// FakeActorCreateSpaceArgs holds the arguments of one call to CreateSpace. +type FakeActorCreateSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorCreateSpaceQuotaArgs holds the arguments of one call to CreateSpaceQuota. +type FakeActorCreateSpaceQuotaArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.QuotaLimits +} + +// FakeActorCreateSpaceRoleArgs holds the arguments of one call to CreateSpaceRole. +type FakeActorCreateSpaceRoleArgs struct { + Arg1 constanta.RoleType + Arg2 string + Arg3 string + Arg4 string + Arg5 string + Arg6 bool +} + +// FakeActorCreateUserArgs holds the arguments of one call to CreateUser. +type FakeActorCreateUserArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorCreateUserProvidedServiceInstanceArgs holds the arguments of one call to CreateUserProvidedServiceInstance. +type FakeActorCreateUserProvidedServiceInstanceArgs struct { + Arg1 resources.ServiceInstance +} + +// FakeActorDeleteApplicationByNameAndSpaceArgs holds the arguments of one call to DeleteApplicationByNameAndSpace. +type FakeActorDeleteApplicationByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 bool +} + +// FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs holds the arguments of one call to DeleteBuildpackByNameAndStackAndLifecycle. +type FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorDeleteDomainArgs holds the arguments of one call to DeleteDomain. +type FakeActorDeleteDomainArgs struct { + Arg1 resources.Domain +} + +// FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs holds the arguments of one call to DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex. +type FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeActorDeleteIsolationSegmentByNameArgs holds the arguments of one call to DeleteIsolationSegmentByName. +type FakeActorDeleteIsolationSegmentByNameArgs struct { + Arg1 string +} + +// FakeActorDeleteIsolationSegmentOrganizationByNameArgs holds the arguments of one call to DeleteIsolationSegmentOrganizationByName. +type FakeActorDeleteIsolationSegmentOrganizationByNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDeleteOrgRoleArgs holds the arguments of one call to DeleteOrgRole. +type FakeActorDeleteOrgRoleArgs struct { + Arg1 constanta.RoleType + Arg2 string + Arg3 string + Arg4 string + Arg5 bool +} + +// FakeActorDeleteOrganizationArgs holds the arguments of one call to DeleteOrganization. +type FakeActorDeleteOrganizationArgs struct { + Arg1 string +} + +// FakeActorDeleteOrganizationQuotaArgs holds the arguments of one call to DeleteOrganizationQuota. +type FakeActorDeleteOrganizationQuotaArgs struct { + Arg1 string +} + +// FakeActorDeleteOrphanedRoutesArgs holds the arguments of one call to DeleteOrphanedRoutes. +type FakeActorDeleteOrphanedRoutesArgs struct { + Arg1 string +} + +// FakeActorDeleteRouteArgs holds the arguments of one call to DeleteRoute. +type FakeActorDeleteRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeActorDeleteRouteBindingArgs holds the arguments of one call to DeleteRouteBinding. +type FakeActorDeleteRouteBindingArgs struct { + Arg1 v7action.DeleteRouteBindingParams +} + +// FakeActorDeleteRoutePolicyBySourceArgs holds the arguments of one call to DeleteRoutePolicyBySource. +type FakeActorDeleteRoutePolicyBySourceArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string +} + +// FakeActorDeleteSecurityGroupArgs holds the arguments of one call to DeleteSecurityGroup. +type FakeActorDeleteSecurityGroupArgs struct { + Arg1 string +} + +// FakeActorDeleteServiceAccountByNameAndSpaceArgs holds the arguments of one call to DeleteServiceAccountByNameAndSpace. +type FakeActorDeleteServiceAccountByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDeleteServiceAppBindingArgs holds the arguments of one call to DeleteServiceAppBinding. +type FakeActorDeleteServiceAppBindingArgs struct { + Arg1 v7action.DeleteServiceAppBindingParams +} + +// FakeActorDeleteServiceBrokerArgs holds the arguments of one call to DeleteServiceBroker. +type FakeActorDeleteServiceBrokerArgs struct { + Arg1 string +} + +// FakeActorDeleteServiceInstanceArgs holds the arguments of one call to DeleteServiceInstance. +type FakeActorDeleteServiceInstanceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs holds the arguments of one call to DeleteServiceKeyByServiceInstanceAndName. +type FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorDeleteSpaceByNameAndOrganizationNameArgs holds the arguments of one call to DeleteSpaceByNameAndOrganizationName. +type FakeActorDeleteSpaceByNameAndOrganizationNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDeleteSpaceQuotaByNameArgs holds the arguments of one call to DeleteSpaceQuotaByName. +type FakeActorDeleteSpaceQuotaByNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDeleteSpaceRoleArgs holds the arguments of one call to DeleteSpaceRole. +type FakeActorDeleteSpaceRoleArgs struct { + Arg1 constanta.RoleType + Arg2 string + Arg3 string + Arg4 string + Arg5 bool +} + +// FakeActorDeleteUserArgs holds the arguments of one call to DeleteUser. +type FakeActorDeleteUserArgs struct { + Arg1 string +} + +// FakeActorDiffSpaceManifestArgs holds the arguments of one call to DiffSpaceManifest. +type FakeActorDiffSpaceManifestArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeActorDisableFeatureFlagArgs holds the arguments of one call to DisableFeatureFlag. +type FakeActorDisableFeatureFlagArgs struct { + Arg1 string +} + +// FakeActorDisableServiceAccessArgs holds the arguments of one call to DisableServiceAccess. +type FakeActorDisableServiceAccessArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string +} + +// FakeActorDownloadCurrentDropletByAppNameArgs holds the arguments of one call to DownloadCurrentDropletByAppName. +type FakeActorDownloadCurrentDropletByAppNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorDownloadDropletByGUIDAndAppNameArgs holds the arguments of one call to DownloadDropletByGUIDAndAppName. +type FakeActorDownloadDropletByGUIDAndAppNameArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorEnableFeatureFlagArgs holds the arguments of one call to EnableFeatureFlag. +type FakeActorEnableFeatureFlagArgs struct { + Arg1 string +} + +// FakeActorEnableServiceAccessArgs holds the arguments of one call to EnableServiceAccess. +type FakeActorEnableServiceAccessArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string +} + +// FakeActorEntitleIsolationSegmentToOrganizationByNameArgs holds the arguments of one call to EntitleIsolationSegmentToOrganizationByName. +type FakeActorEntitleIsolationSegmentToOrganizationByNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetAppFeatureArgs holds the arguments of one call to GetAppFeature. +type FakeActorGetAppFeatureArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetAppSummariesForSpaceArgs holds the arguments of one call to GetAppSummariesForSpace. +type FakeActorGetAppSummariesForSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 bool +} + +// FakeActorGetApplicationByNameAndSpaceArgs holds the arguments of one call to GetApplicationByNameAndSpace. +type FakeActorGetApplicationByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationDropletsArgs holds the arguments of one call to GetApplicationDroplets. +type FakeActorGetApplicationDropletsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationLabelsArgs holds the arguments of one call to GetApplicationLabels. +type FakeActorGetApplicationLabelsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationMapForRouteArgs holds the arguments of one call to GetApplicationMapForRoute. +type FakeActorGetApplicationMapForRouteArgs struct { + Arg1 resources.Route +} + +// FakeActorGetApplicationPackagesArgs holds the arguments of one call to GetApplicationPackages. +type FakeActorGetApplicationPackagesArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs holds the arguments of one call to GetApplicationProcessHealthChecksByNameAndSpace. +type FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs holds the arguments of one call to GetApplicationProcessReadinessHealthChecksByNameAndSpace. +type FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetApplicationRevisionsDeployedArgs holds the arguments of one call to GetApplicationRevisionsDeployed. +type FakeActorGetApplicationRevisionsDeployedArgs struct { + Arg1 string +} + +// FakeActorGetApplicationRoutesArgs holds the arguments of one call to GetApplicationRoutes. +type FakeActorGetApplicationRoutesArgs struct { + Arg1 string +} + +// FakeActorGetApplicationTasksArgs holds the arguments of one call to GetApplicationTasks. +type FakeActorGetApplicationTasksArgs struct { + Arg1 string + Arg2 v7action.SortOrder +} + +// FakeActorGetApplicationsByGUIDsArgs holds the arguments of one call to GetApplicationsByGUIDs. +type FakeActorGetApplicationsByGUIDsArgs struct { + Arg1 []string +} + +// FakeActorGetApplicationsByNamesAndSpaceArgs holds the arguments of one call to GetApplicationsByNamesAndSpace. +type FakeActorGetApplicationsByNamesAndSpaceArgs struct { + Arg1 []string + Arg2 string +} + +// FakeActorGetBuildpackLabelsArgs holds the arguments of one call to GetBuildpackLabels. +type FakeActorGetBuildpackLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetBuildpacksArgs holds the arguments of one call to GetBuildpacks. +type FakeActorGetBuildpacksArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetDefaultDomainArgs holds the arguments of one call to GetDefaultDomain. +type FakeActorGetDefaultDomainArgs struct { + Arg1 string +} + +// FakeActorGetDetailedAppSummaryArgs holds the arguments of one call to GetDetailedAppSummary. +type FakeActorGetDetailedAppSummaryArgs struct { + Arg1 string + Arg2 string + Arg3 bool +} + +// FakeActorGetDomainArgs holds the arguments of one call to GetDomain. +type FakeActorGetDomainArgs struct { + Arg1 string +} + +// FakeActorGetDomainByNameArgs holds the arguments of one call to GetDomainByName. +type FakeActorGetDomainByNameArgs struct { + Arg1 string +} + +// FakeActorGetDomainLabelsArgs holds the arguments of one call to GetDomainLabels. +type FakeActorGetDomainLabelsArgs struct { + Arg1 string +} + +// FakeActorGetEffectiveIsolationSegmentBySpaceArgs holds the arguments of one call to GetEffectiveIsolationSegmentBySpace. +type FakeActorGetEffectiveIsolationSegmentBySpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetEnvironmentVariableGroupArgs holds the arguments of one call to GetEnvironmentVariableGroup. +type FakeActorGetEnvironmentVariableGroupArgs struct { + Arg1 constanta.EnvironmentVariableGroupName +} + +// FakeActorGetEnvironmentVariableGroupByRevisionArgs holds the arguments of one call to GetEnvironmentVariableGroupByRevision. +type FakeActorGetEnvironmentVariableGroupByRevisionArgs struct { + Arg1 resources.Revision +} + +// FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs holds the arguments of one call to GetEnvironmentVariablesByApplicationNameAndSpace. +type FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetFeatureFlagByNameArgs holds the arguments of one call to GetFeatureFlagByName. +type FakeActorGetFeatureFlagByNameArgs struct { + Arg1 string +} + +// FakeActorGetIsolationSegmentByNameArgs holds the arguments of one call to GetIsolationSegmentByName. +type FakeActorGetIsolationSegmentByNameArgs struct { + Arg1 string +} + +// FakeActorGetIsolationSegmentsByOrganizationArgs holds the arguments of one call to GetIsolationSegmentsByOrganization. +type FakeActorGetIsolationSegmentsByOrganizationArgs struct { + Arg1 string +} + +// FakeActorGetLatestActiveDeploymentForAppArgs holds the arguments of one call to GetLatestActiveDeploymentForApp. +type FakeActorGetLatestActiveDeploymentForAppArgs struct { + Arg1 string +} + +// FakeActorGetNewestReadyPackageForApplicationArgs holds the arguments of one call to GetNewestReadyPackageForApplication. +type FakeActorGetNewestReadyPackageForApplicationArgs struct { + Arg1 resources.Application +} + +// FakeActorGetOrgUsersByRoleTypeArgs holds the arguments of one call to GetOrgUsersByRoleType. +type FakeActorGetOrgUsersByRoleTypeArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationByNameArgs holds the arguments of one call to GetOrganizationByName. +type FakeActorGetOrganizationByNameArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationDomainsArgs holds the arguments of one call to GetOrganizationDomains. +type FakeActorGetOrganizationDomainsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetOrganizationLabelsArgs holds the arguments of one call to GetOrganizationLabels. +type FakeActorGetOrganizationLabelsArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationQuotaByNameArgs holds the arguments of one call to GetOrganizationQuotaByName. +type FakeActorGetOrganizationQuotaByNameArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationSpacesArgs holds the arguments of one call to GetOrganizationSpaces. +type FakeActorGetOrganizationSpacesArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationSpacesWithLabelSelectorArgs holds the arguments of one call to GetOrganizationSpacesWithLabelSelector. +type FakeActorGetOrganizationSpacesWithLabelSelectorArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetOrganizationSummaryByNameArgs holds the arguments of one call to GetOrganizationSummaryByName. +type FakeActorGetOrganizationSummaryByNameArgs struct { + Arg1 string +} + +// FakeActorGetOrganizationsArgs holds the arguments of one call to GetOrganizations. +type FakeActorGetOrganizationsArgs struct { + Arg1 string +} + +// FakeActorGetProcessByTypeAndApplicationArgs holds the arguments of one call to GetProcessByTypeAndApplication. +type FakeActorGetProcessByTypeAndApplicationArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRawApplicationManifestByNameAndSpaceArgs holds the arguments of one call to GetRawApplicationManifestByNameAndSpace. +type FakeActorGetRawApplicationManifestByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRecentEventsByApplicationNameAndSpaceArgs holds the arguments of one call to GetRecentEventsByApplicationNameAndSpace. +type FakeActorGetRecentEventsByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs holds the arguments of one call to GetRecentLogsForApplicationByNameAndSpace. +type FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 sharedaction.LogCacheClient +} + +// FakeActorGetRevisionByApplicationAndVersionArgs holds the arguments of one call to GetRevisionByApplicationAndVersion. +type FakeActorGetRevisionByApplicationAndVersionArgs struct { + Arg1 string + Arg2 int +} + +// FakeActorGetRevisionsByApplicationNameAndSpaceArgs holds the arguments of one call to GetRevisionsByApplicationNameAndSpace. +type FakeActorGetRevisionsByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRouteByAttributesArgs holds the arguments of one call to GetRouteByAttributes. +type FakeActorGetRouteByAttributesArgs struct { + Arg1 resources.Domain + Arg2 string + Arg3 string + Arg4 int +} + +// FakeActorGetRouteDestinationByAppGUIDArgs holds the arguments of one call to GetRouteDestinationByAppGUID. +type FakeActorGetRouteDestinationByAppGUIDArgs struct { + Arg1 resources.Route + Arg2 string +} + +// FakeActorGetRouteLabelsArgs holds the arguments of one call to GetRouteLabels. +type FakeActorGetRouteLabelsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRoutePoliciesByRouteArgs holds the arguments of one call to GetRoutePoliciesByRoute. +type FakeActorGetRoutePoliciesByRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetRoutePoliciesForSpaceArgs holds the arguments of one call to GetRoutePoliciesForSpace. +type FakeActorGetRoutePoliciesForSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 string + Arg5 string +} + +// FakeActorGetRoutePolicyLabelsArgs holds the arguments of one call to GetRoutePolicyLabels. +type FakeActorGetRoutePolicyLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetRouteSummariesArgs holds the arguments of one call to GetRouteSummaries. +type FakeActorGetRouteSummariesArgs struct { + Arg1 []resources.Route +} + +// FakeActorGetRoutesByOrgArgs holds the arguments of one call to GetRoutesByOrg. +type FakeActorGetRoutesByOrgArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetRoutesBySpaceArgs holds the arguments of one call to GetRoutesBySpace. +type FakeActorGetRoutesBySpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSSHEnabledArgs holds the arguments of one call to GetSSHEnabled. +type FakeActorGetSSHEnabledArgs struct { + Arg1 string +} + +// FakeActorGetSSHEnabledByAppNameArgs holds the arguments of one call to GetSSHEnabledByAppName. +type FakeActorGetSSHEnabledByAppNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs holds the arguments of one call to GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex. +type FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 uint +} + +// FakeActorGetSecurityGroupArgs holds the arguments of one call to GetSecurityGroup. +type FakeActorGetSecurityGroupArgs struct { + Arg1 string +} + +// FakeActorGetSecurityGroupSummaryArgs holds the arguments of one call to GetSecurityGroupSummary. +type FakeActorGetSecurityGroupSummaryArgs struct { + Arg1 string +} + +// FakeActorGetServiceAccessArgs holds the arguments of one call to GetServiceAccess. +type FakeActorGetServiceAccessArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetServiceAccountByNameAndSpaceArgs holds the arguments of one call to GetServiceAccountByNameAndSpace. +type FakeActorGetServiceAccountByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServiceAccountsInSpaceArgs holds the arguments of one call to GetServiceAccountsInSpace. +type FakeActorGetServiceAccountsInSpaceArgs struct { + Arg1 string +} + +// FakeActorGetServiceBrokerByNameArgs holds the arguments of one call to GetServiceBrokerByName. +type FakeActorGetServiceBrokerByNameArgs struct { + Arg1 string +} + +// FakeActorGetServiceBrokerLabelsArgs holds the arguments of one call to GetServiceBrokerLabels. +type FakeActorGetServiceBrokerLabelsArgs struct { + Arg1 string +} + +// FakeActorGetServiceInstanceByGUIDArgs holds the arguments of one call to GetServiceInstanceByGUID. +type FakeActorGetServiceInstanceByGUIDArgs struct { + Arg1 string +} + +// FakeActorGetServiceInstanceByNameAndSpaceArgs holds the arguments of one call to GetServiceInstanceByNameAndSpace. +type FakeActorGetServiceInstanceByNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServiceInstanceDetailsArgs holds the arguments of one call to GetServiceInstanceDetails. +type FakeActorGetServiceInstanceDetailsArgs struct { + Arg1 string + Arg2 string + Arg3 bool +} + +// FakeActorGetServiceInstanceLabelsArgs holds the arguments of one call to GetServiceInstanceLabels. +type FakeActorGetServiceInstanceLabelsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServiceInstanceParametersArgs holds the arguments of one call to GetServiceInstanceParameters. +type FakeActorGetServiceInstanceParametersArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServiceInstancesForSpaceArgs holds the arguments of one call to GetServiceInstancesForSpace. +type FakeActorGetServiceInstancesForSpaceArgs struct { + Arg1 string + Arg2 bool +} + +// FakeActorGetServiceKeyByServiceInstanceAndNameArgs holds the arguments of one call to GetServiceKeyByServiceInstanceAndName. +type FakeActorGetServiceKeyByServiceInstanceAndNameArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs holds the arguments of one call to GetServiceKeyDetailsByServiceInstanceAndName. +type FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetServiceKeysByServiceInstanceArgs holds the arguments of one call to GetServiceKeysByServiceInstance. +type FakeActorGetServiceKeysByServiceInstanceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServiceOfferingLabelsArgs holds the arguments of one call to GetServiceOfferingLabels. +type FakeActorGetServiceOfferingLabelsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetServicePlanByNameOfferingAndBrokerArgs holds the arguments of one call to GetServicePlanByNameOfferingAndBroker. +type FakeActorGetServicePlanByNameOfferingAndBrokerArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetServicePlanLabelsArgs holds the arguments of one call to GetServicePlanLabels. +type FakeActorGetServicePlanLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetSpaceByNameAndOrganizationArgs holds the arguments of one call to GetSpaceByNameAndOrganization. +type FakeActorGetSpaceByNameAndOrganizationArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSpaceFeatureArgs holds the arguments of one call to GetSpaceFeature. +type FakeActorGetSpaceFeatureArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorGetSpaceLabelsArgs holds the arguments of one call to GetSpaceLabels. +type FakeActorGetSpaceLabelsArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSpaceQuotaByNameArgs holds the arguments of one call to GetSpaceQuotaByName. +type FakeActorGetSpaceQuotaByNameArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSpaceQuotasByOrgGUIDArgs holds the arguments of one call to GetSpaceQuotasByOrgGUID. +type FakeActorGetSpaceQuotasByOrgGUIDArgs struct { + Arg1 string +} + +// FakeActorGetSpaceSummaryByNameAndOrganizationArgs holds the arguments of one call to GetSpaceSummaryByNameAndOrganization. +type FakeActorGetSpaceSummaryByNameAndOrganizationArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorGetSpaceUsersByRoleTypeArgs holds the arguments of one call to GetSpaceUsersByRoleType. +type FakeActorGetSpaceUsersByRoleTypeArgs struct { + Arg1 string +} + +// FakeActorGetStackByNameArgs holds the arguments of one call to GetStackByName. +type FakeActorGetStackByNameArgs struct { + Arg1 string +} + +// FakeActorGetStackLabelsArgs holds the arguments of one call to GetStackLabels. +type FakeActorGetStackLabelsArgs struct { + Arg1 string +} + +// FakeActorGetStacksArgs holds the arguments of one call to GetStacks. +type FakeActorGetStacksArgs struct { + Arg1 string +} + +// FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs holds the arguments of one call to GetStreamingLogsForApplicationByNameAndSpace. +type FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 sharedaction.LogCacheClient +} + +// FakeActorGetTaskBySequenceIDAndApplicationArgs holds the arguments of one call to GetTaskBySequenceIDAndApplication. +type FakeActorGetTaskBySequenceIDAndApplicationArgs struct { + Arg1 int + Arg2 string +} + +// FakeActorGetUnstagedNewestPackageGUIDArgs holds the arguments of one call to GetUnstagedNewestPackageGUID. +type FakeActorGetUnstagedNewestPackageGUIDArgs struct { + Arg1 string +} + +// FakeActorGetUserArgs holds the arguments of one call to GetUser. +type FakeActorGetUserArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorListAppBindingsArgs holds the arguments of one call to ListAppBindings. +type FakeActorListAppBindingsArgs struct { + Arg1 v7action.ListAppBindingParams +} + +// FakeActorListServiceAppBindingsArgs holds the arguments of one call to ListServiceAppBindings. +type FakeActorListServiceAppBindingsArgs struct { + Arg1 v7action.ListServiceAppBindingParams +} + +// FakeActorMakeCurlRequestArgs holds the arguments of one call to MakeCurlRequest. +type FakeActorMakeCurlRequestArgs struct { + Arg1 string + Arg2 string + Arg3 []string + Arg4 string + Arg5 bool +} + +// FakeActorMapRouteArgs holds the arguments of one call to MapRoute. +type FakeActorMapRouteArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 int +} + +// FakeActorMarketplaceArgs holds the arguments of one call to Marketplace. +type FakeActorMarketplaceArgs struct { + Arg1 v7action.MarketplaceFilter +} + +// FakeActorMoveRouteArgs holds the arguments of one call to MoveRoute. +type FakeActorMoveRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorParseAccessTokenArgs holds the arguments of one call to ParseAccessToken. +type FakeActorParseAccessTokenArgs struct { + Arg1 string +} + +// FakeActorPollBuildArgs holds the arguments of one call to PollBuild. +type FakeActorPollBuildArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorPollPackageArgs holds the arguments of one call to PollPackage. +type FakeActorPollPackageArgs struct { + Arg1 resources.Package +} + +// FakeActorPollStartArgs holds the arguments of one call to PollStart. +type FakeActorPollStartArgs struct { + Arg1 resources.Application + Arg2 bool + Arg3 func(string) +} + +// FakeActorPollStartForDeploymentArgs holds the arguments of one call to PollStartForDeployment. +type FakeActorPollStartForDeploymentArgs struct { + Arg1 resources.Application + Arg2 string + Arg3 bool + Arg4 func(string) +} + +// FakeActorPollTaskArgs holds the arguments of one call to PollTask. +type FakeActorPollTaskArgs struct { + Arg1 resources.Task +} + +// FakeActorPollUploadBuildpackJobArgs holds the arguments of one call to PollUploadBuildpackJob. +type FakeActorPollUploadBuildpackJobArgs struct { + Arg1 ccv3.JobURL +} + +// FakeActorPrepareBuildpackBitsArgs holds the arguments of one call to PrepareBuildpackBits. +type FakeActorPrepareBuildpackBitsArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.Downloader +} + +// FakeActorPurgeServiceInstanceArgs holds the arguments of one call to PurgeServiceInstance. +type FakeActorPurgeServiceInstanceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorPurgeServiceOfferingByNameAndBrokerArgs holds the arguments of one call to PurgeServiceOfferingByNameAndBroker. +type FakeActorPurgeServiceOfferingByNameAndBrokerArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorRenameApplicationByNameAndSpaceGUIDArgs holds the arguments of one call to RenameApplicationByNameAndSpaceGUID. +type FakeActorRenameApplicationByNameAndSpaceGUIDArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorRenameOrganizationArgs holds the arguments of one call to RenameOrganization. +type FakeActorRenameOrganizationArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorRenameServiceInstanceArgs holds the arguments of one call to RenameServiceInstance. +type FakeActorRenameServiceInstanceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorRenameSpaceByNameAndOrganizationGUIDArgs holds the arguments of one call to RenameSpaceByNameAndOrganizationGUID. +type FakeActorRenameSpaceByNameAndOrganizationGUIDArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorResetOrganizationDefaultIsolationSegmentArgs holds the arguments of one call to ResetOrganizationDefaultIsolationSegment. +type FakeActorResetOrganizationDefaultIsolationSegmentArgs struct { + Arg1 string +} + +// FakeActorResetSpaceIsolationSegmentArgs holds the arguments of one call to ResetSpaceIsolationSegment. +type FakeActorResetSpaceIsolationSegmentArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorResourceMatchArgs holds the arguments of one call to ResourceMatch. +type FakeActorResourceMatchArgs struct { + Arg1 []sharedaction.V3Resource +} + +// FakeActorRestartApplicationArgs holds the arguments of one call to RestartApplication. +type FakeActorRestartApplicationArgs struct { + Arg1 string + Arg2 bool +} + +// FakeActorRunTaskArgs holds the arguments of one call to RunTask. +type FakeActorRunTaskArgs struct { + Arg1 string + Arg2 resources.Task +} + +// FakeActorScaleProcessByApplicationArgs holds the arguments of one call to ScaleProcessByApplication. +type FakeActorScaleProcessByApplicationArgs struct { + Arg1 string + Arg2 resources.Process +} + +// FakeActorScheduleTokenRefreshArgs holds the arguments of one call to ScheduleTokenRefresh. +type FakeActorScheduleTokenRefreshArgs struct { + Arg1 func(time.Duration) <-chan time.Time + Arg2 chan struct{} + Arg3 chan struct{} +} + +// FakeActorSetApplicationDropletArgs holds the arguments of one call to SetApplicationDroplet. +type FakeActorSetApplicationDropletArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs holds the arguments of one call to SetApplicationDropletByApplicationNameAndSpace. +type FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorSetApplicationManifestArgs holds the arguments of one call to SetApplicationManifest. +type FakeActorSetApplicationManifestArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs holds the arguments of one call to SetApplicationProcessHealthCheckTypeByNameAndSpace. +type FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 constanta.HealthCheckType + Arg4 string + Arg5 string + Arg6 int64 +} + +// FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs holds the arguments of one call to SetEnvironmentVariableByApplicationNameAndSpace. +type FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.EnvironmentVariablePair +} + +// FakeActorSetEnvironmentVariableGroupArgs holds the arguments of one call to SetEnvironmentVariableGroup. +type FakeActorSetEnvironmentVariableGroupArgs struct { + Arg1 constanta.EnvironmentVariableGroupName + Arg2 resources.EnvironmentVariables +} + +// FakeActorSetOrganizationDefaultIsolationSegmentArgs holds the arguments of one call to SetOrganizationDefaultIsolationSegment. +type FakeActorSetOrganizationDefaultIsolationSegmentArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorSetServiceAccountEnabledByNameAndSpaceArgs holds the arguments of one call to SetServiceAccountEnabledByNameAndSpace. +type FakeActorSetServiceAccountEnabledByNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 bool +} + +// FakeActorSetSpaceManifestArgs holds the arguments of one call to SetSpaceManifest. +type FakeActorSetSpaceManifestArgs struct { + Arg1 string + Arg2 []byte +} + +// FakeActorSetTargetArgs holds the arguments of one call to SetTarget. +type FakeActorSetTargetArgs struct { + Arg1 v7action.TargetSettings +} + +// FakeActorSharePrivateDomainArgs holds the arguments of one call to SharePrivateDomain. +type FakeActorSharePrivateDomainArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorShareRouteArgs holds the arguments of one call to ShareRoute. +type FakeActorShareRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorShareServiceInstanceToSpaceAndOrgArgs holds the arguments of one call to ShareServiceInstanceToSpaceAndOrg. +type FakeActorShareServiceInstanceToSpaceAndOrgArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 v7action.ServiceInstanceSharingParams +} + +// FakeActorStageApplicationPackageArgs holds the arguments of one call to StageApplicationPackage. +type FakeActorStageApplicationPackageArgs struct { + Arg1 string +} + +// FakeActorStagePackageArgs holds the arguments of one call to StagePackage. +type FakeActorStagePackageArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorStartApplicationArgs holds the arguments of one call to StartApplication. +type FakeActorStartApplicationArgs struct { + Arg1 string +} + +// FakeActorStopApplicationArgs holds the arguments of one call to StopApplication. +type FakeActorStopApplicationArgs struct { + Arg1 string +} + +// FakeActorTerminateTaskArgs holds the arguments of one call to TerminateTask. +type FakeActorTerminateTaskArgs struct { + Arg1 string +} + +// FakeActorUnbindSecurityGroupArgs holds the arguments of one call to UnbindSecurityGroup. +type FakeActorUnbindSecurityGroupArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 constanta.SecurityGroupLifecycle +} + +// FakeActorUnbindServiceAccountByAppNameAndSpaceArgs holds the arguments of one call to UnbindServiceAccountByAppNameAndSpace. +type FakeActorUnbindServiceAccountByAppNameAndSpaceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUnmapRouteArgs holds the arguments of one call to UnmapRoute. +type FakeActorUnmapRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs holds the arguments of one call to UnsetEnvironmentVariableByApplicationNameAndSpace. +type FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorUnsetSpaceQuotaArgs holds the arguments of one call to UnsetSpaceQuota. +type FakeActorUnsetSpaceQuotaArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorUnsharePrivateDomainArgs holds the arguments of one call to UnsharePrivateDomain. +type FakeActorUnsharePrivateDomainArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUnshareRouteArgs holds the arguments of one call to UnshareRoute. +type FakeActorUnshareRouteArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs holds the arguments of one call to UnshareServiceInstanceFromSpaceAndOrg. +type FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 v7action.ServiceInstanceSharingParams +} + +// FakeActorUpdateAppFeatureArgs holds the arguments of one call to UpdateAppFeature. +type FakeActorUpdateAppFeatureArgs struct { + Arg1 resources.Application + Arg2 bool + Arg3 string +} + +// FakeActorUpdateApplicationArgs holds the arguments of one call to UpdateApplication. +type FakeActorUpdateApplicationArgs struct { + Arg1 resources.Application +} + +// FakeActorUpdateApplicationLabelsByApplicationNameArgs holds the arguments of one call to UpdateApplicationLabelsByApplicationName. +type FakeActorUpdateApplicationLabelsByApplicationNameArgs struct { + Arg1 string + Arg2 string + Arg3 map[string]types.NullString +} + +// FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs holds the arguments of one call to UpdateBuildpackByNameAndStackAndLifecycle. +type FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 resources.Buildpack +} + +// FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs holds the arguments of one call to UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycle. +type FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 map[string]types.NullString +} + +// FakeActorUpdateDestinationArgs holds the arguments of one call to UpdateDestination. +type FakeActorUpdateDestinationArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorUpdateDomainLabelsByDomainNameArgs holds the arguments of one call to UpdateDomainLabelsByDomainName. +type FakeActorUpdateDomainLabelsByDomainNameArgs struct { + Arg1 string + Arg2 map[string]types.NullString +} + +// FakeActorUpdateManagedServiceInstanceArgs holds the arguments of one call to UpdateManagedServiceInstance. +type FakeActorUpdateManagedServiceInstanceArgs struct { + Arg1 v7action.UpdateManagedServiceInstanceParams +} + +// FakeActorUpdateOrganizationLabelsByOrganizationNameArgs holds the arguments of one call to UpdateOrganizationLabelsByOrganizationName. +type FakeActorUpdateOrganizationLabelsByOrganizationNameArgs struct { + Arg1 string + Arg2 map[string]types.NullString +} + +// FakeActorUpdateOrganizationQuotaArgs holds the arguments of one call to UpdateOrganizationQuota. +type FakeActorUpdateOrganizationQuotaArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.QuotaLimits +} + +// FakeActorUpdateProcessByTypeAndApplicationArgs holds the arguments of one call to UpdateProcessByTypeAndApplication. +type FakeActorUpdateProcessByTypeAndApplicationArgs struct { + Arg1 string + Arg2 string + Arg3 resources.Process +} + +// FakeActorUpdateRouteArgs holds the arguments of one call to UpdateRoute. +type FakeActorUpdateRouteArgs struct { + Arg1 string + Arg2 map[string]*string +} + +// FakeActorUpdateRouteLabelsArgs holds the arguments of one call to UpdateRouteLabels. +type FakeActorUpdateRouteLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 map[string]types.NullString +} + +// FakeActorUpdateRoutePolicyLabelsArgs holds the arguments of one call to UpdateRoutePolicyLabels. +type FakeActorUpdateRoutePolicyLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 map[string]types.NullString +} + +// FakeActorUpdateSecurityGroupArgs holds the arguments of one call to UpdateSecurityGroup. +type FakeActorUpdateSecurityGroupArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUpdateSecurityGroupGloballyEnabledArgs holds the arguments of one call to UpdateSecurityGroupGloballyEnabled. +type FakeActorUpdateSecurityGroupGloballyEnabledArgs struct { + Arg1 string + Arg2 constanta.SecurityGroupLifecycle + Arg3 bool +} + +// FakeActorUpdateServiceBrokerArgs holds the arguments of one call to UpdateServiceBroker. +type FakeActorUpdateServiceBrokerArgs struct { + Arg1 string + Arg2 resources.ServiceBroker +} + +// FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs holds the arguments of one call to UpdateServiceBrokerLabelsByServiceBrokerName. +type FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs struct { + Arg1 string + Arg2 map[string]types.NullString +} + +// FakeActorUpdateServiceInstanceLabelsArgs holds the arguments of one call to UpdateServiceInstanceLabels. +type FakeActorUpdateServiceInstanceLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 map[string]types.NullString +} + +// FakeActorUpdateServiceOfferingLabelsArgs holds the arguments of one call to UpdateServiceOfferingLabels. +type FakeActorUpdateServiceOfferingLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 map[string]types.NullString +} + +// FakeActorUpdateServicePlanLabelsArgs holds the arguments of one call to UpdateServicePlanLabels. +type FakeActorUpdateServicePlanLabelsArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 map[string]types.NullString +} + +// FakeActorUpdateSpaceFeatureArgs holds the arguments of one call to UpdateSpaceFeature. +type FakeActorUpdateSpaceFeatureArgs struct { + Arg1 string + Arg2 string + Arg3 bool + Arg4 string +} + +// FakeActorUpdateSpaceLabelsBySpaceNameArgs holds the arguments of one call to UpdateSpaceLabelsBySpaceName. +type FakeActorUpdateSpaceLabelsBySpaceNameArgs struct { + Arg1 string + Arg2 string + Arg3 map[string]types.NullString +} + +// FakeActorUpdateSpaceQuotaArgs holds the arguments of one call to UpdateSpaceQuota. +type FakeActorUpdateSpaceQuotaArgs struct { + Arg1 string + Arg2 string + Arg3 string + Arg4 v7action.QuotaLimits +} + +// FakeActorUpdateStackArgs holds the arguments of one call to UpdateStack. +type FakeActorUpdateStackArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorUpdateStackLabelsByStackNameArgs holds the arguments of one call to UpdateStackLabelsByStackName. +type FakeActorUpdateStackLabelsByStackNameArgs struct { + Arg1 string + Arg2 map[string]types.NullString +} + +// FakeActorUpdateUserPasswordArgs holds the arguments of one call to UpdateUserPassword. +type FakeActorUpdateUserPasswordArgs struct { + Arg1 string + Arg2 string + Arg3 string +} + +// FakeActorUpdateUserProvidedServiceInstanceArgs holds the arguments of one call to UpdateUserProvidedServiceInstance. +type FakeActorUpdateUserProvidedServiceInstanceArgs struct { + Arg1 string + Arg2 string + Arg3 resources.ServiceInstance +} + +// FakeActorUpgradeManagedServiceInstanceArgs holds the arguments of one call to UpgradeManagedServiceInstance. +type FakeActorUpgradeManagedServiceInstanceArgs struct { + Arg1 string + Arg2 string +} + +// FakeActorUploadBitsPackageArgs holds the arguments of one call to UploadBitsPackage. +type FakeActorUploadBitsPackageArgs struct { + Arg1 resources.Package + Arg2 []sharedaction.V3Resource + Arg3 io.Reader + Arg4 int64 +} + +// FakeActorUploadBuildpackArgs holds the arguments of one call to UploadBuildpack. +type FakeActorUploadBuildpackArgs struct { + Arg1 string + Arg2 string + Arg3 v7action.SimpleProgressBar +} + +// FakeActorUploadDropletArgs holds the arguments of one call to UploadDroplet. +type FakeActorUploadDropletArgs struct { + Arg1 string + Arg2 string + Arg3 io.Reader + Arg4 int64 +} + func (fake *FakeActor) AddRoutePolicy(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { fake.addRoutePolicyMutex.Lock() ret, specificReturn := fake.addRoutePolicyReturnsOnCall[len(fake.addRoutePolicyArgsForCall)] - fake.addRoutePolicyArgsForCall = append(fake.addRoutePolicyArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.addRoutePolicyArgsForCall = append(fake.addRoutePolicyArgsForCall, FakeActorAddRoutePolicyArgs{arg1, arg2, arg3, arg4}) stub := fake.AddRoutePolicyStub fakeReturns := fake.addRoutePolicyReturns fake.recordInvocation("AddRoutePolicy", []interface{}{arg1, arg2, arg3, arg4}) @@ -3929,7 +4746,15 @@ func (fake *FakeActor) AddRoutePolicyArgsForCall(i int) (string, string, string, fake.addRoutePolicyMutex.RLock() defer fake.addRoutePolicyMutex.RUnlock() argsForCall := fake.addRoutePolicyArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) AddRoutePolicyArgs() []FakeActorAddRoutePolicyArgs { + fake.addRoutePolicyMutex.RLock() + defer fake.addRoutePolicyMutex.RUnlock() + args := make([]FakeActorAddRoutePolicyArgs, len(fake.addRoutePolicyArgsForCall)) + copy(args, fake.addRoutePolicyArgsForCall) + return args } func (fake *FakeActor) AddRoutePolicyReturns(result1 v7action.Warnings, result2 error) { @@ -3961,10 +4786,7 @@ func (fake *FakeActor) AddRoutePolicyReturnsOnCall(i int, result1 v7action.Warni func (fake *FakeActor) ApplyOrganizationQuotaByName(arg1 string, arg2 string) (v7action.Warnings, error) { fake.applyOrganizationQuotaByNameMutex.Lock() ret, specificReturn := fake.applyOrganizationQuotaByNameReturnsOnCall[len(fake.applyOrganizationQuotaByNameArgsForCall)] - fake.applyOrganizationQuotaByNameArgsForCall = append(fake.applyOrganizationQuotaByNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.applyOrganizationQuotaByNameArgsForCall = append(fake.applyOrganizationQuotaByNameArgsForCall, FakeActorApplyOrganizationQuotaByNameArgs{arg1, arg2}) stub := fake.ApplyOrganizationQuotaByNameStub fakeReturns := fake.applyOrganizationQuotaByNameReturns fake.recordInvocation("ApplyOrganizationQuotaByName", []interface{}{arg1, arg2}) @@ -3994,7 +4816,15 @@ func (fake *FakeActor) ApplyOrganizationQuotaByNameArgsForCall(i int) (string, s fake.applyOrganizationQuotaByNameMutex.RLock() defer fake.applyOrganizationQuotaByNameMutex.RUnlock() argsForCall := fake.applyOrganizationQuotaByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) ApplyOrganizationQuotaByNameArgs() []FakeActorApplyOrganizationQuotaByNameArgs { + fake.applyOrganizationQuotaByNameMutex.RLock() + defer fake.applyOrganizationQuotaByNameMutex.RUnlock() + args := make([]FakeActorApplyOrganizationQuotaByNameArgs, len(fake.applyOrganizationQuotaByNameArgsForCall)) + copy(args, fake.applyOrganizationQuotaByNameArgsForCall) + return args } func (fake *FakeActor) ApplyOrganizationQuotaByNameReturns(result1 v7action.Warnings, result2 error) { @@ -4026,11 +4856,7 @@ func (fake *FakeActor) ApplyOrganizationQuotaByNameReturnsOnCall(i int, result1 func (fake *FakeActor) ApplySpaceQuotaByName(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.applySpaceQuotaByNameMutex.Lock() ret, specificReturn := fake.applySpaceQuotaByNameReturnsOnCall[len(fake.applySpaceQuotaByNameArgsForCall)] - fake.applySpaceQuotaByNameArgsForCall = append(fake.applySpaceQuotaByNameArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.applySpaceQuotaByNameArgsForCall = append(fake.applySpaceQuotaByNameArgsForCall, FakeActorApplySpaceQuotaByNameArgs{arg1, arg2, arg3}) stub := fake.ApplySpaceQuotaByNameStub fakeReturns := fake.applySpaceQuotaByNameReturns fake.recordInvocation("ApplySpaceQuotaByName", []interface{}{arg1, arg2, arg3}) @@ -4060,7 +4886,15 @@ func (fake *FakeActor) ApplySpaceQuotaByNameArgsForCall(i int) (string, string, fake.applySpaceQuotaByNameMutex.RLock() defer fake.applySpaceQuotaByNameMutex.RUnlock() argsForCall := fake.applySpaceQuotaByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) ApplySpaceQuotaByNameArgs() []FakeActorApplySpaceQuotaByNameArgs { + fake.applySpaceQuotaByNameMutex.RLock() + defer fake.applySpaceQuotaByNameMutex.RUnlock() + args := make([]FakeActorApplySpaceQuotaByNameArgs, len(fake.applySpaceQuotaByNameArgsForCall)) + copy(args, fake.applySpaceQuotaByNameArgsForCall) + return args } func (fake *FakeActor) ApplySpaceQuotaByNameReturns(result1 v7action.Warnings, result2 error) { @@ -4092,10 +4926,7 @@ func (fake *FakeActor) ApplySpaceQuotaByNameReturnsOnCall(i int, result1 v7actio func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpace(arg1 string, arg2 string) (v7action.Warnings, error) { fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Lock() ret, specificReturn := fake.assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall[len(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall)] - fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall = append(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall = append(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall, FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs{arg1, arg2}) stub := fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub fakeReturns := fake.assignIsolationSegmentToSpaceByNameAndSpaceReturns fake.recordInvocation("AssignIsolationSegmentToSpaceByNameAndSpace", []interface{}{arg1, arg2}) @@ -4125,7 +4956,15 @@ func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceArgsForCall(i fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RLock() defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RUnlock() argsForCall := fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceArgs() []FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs { + fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RLock() + defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorAssignIsolationSegmentToSpaceByNameAndSpaceArgs, len(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall)) + copy(args, fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { @@ -4157,11 +4996,7 @@ func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall( func (fake *FakeActor) Authenticate(arg1 map[string]string, arg2 string, arg3 constant.GrantType) error { fake.authenticateMutex.Lock() ret, specificReturn := fake.authenticateReturnsOnCall[len(fake.authenticateArgsForCall)] - fake.authenticateArgsForCall = append(fake.authenticateArgsForCall, struct { - arg1 map[string]string - arg2 string - arg3 constant.GrantType - }{arg1, arg2, arg3}) + fake.authenticateArgsForCall = append(fake.authenticateArgsForCall, FakeActorAuthenticateArgs{arg1, arg2, arg3}) stub := fake.AuthenticateStub fakeReturns := fake.authenticateReturns fake.recordInvocation("Authenticate", []interface{}{arg1, arg2, arg3}) @@ -4191,7 +5026,15 @@ func (fake *FakeActor) AuthenticateArgsForCall(i int) (map[string]string, string fake.authenticateMutex.RLock() defer fake.authenticateMutex.RUnlock() argsForCall := fake.authenticateArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) AuthenticateArgs() []FakeActorAuthenticateArgs { + fake.authenticateMutex.RLock() + defer fake.authenticateMutex.RUnlock() + args := make([]FakeActorAuthenticateArgs, len(fake.authenticateArgsForCall)) + copy(args, fake.authenticateArgsForCall) + return args } func (fake *FakeActor) AuthenticateReturns(result1 error) { @@ -4225,11 +5068,7 @@ func (fake *FakeActor) BindSecurityGroupToSpaces(arg1 string, arg2 []resources.S } fake.bindSecurityGroupToSpacesMutex.Lock() ret, specificReturn := fake.bindSecurityGroupToSpacesReturnsOnCall[len(fake.bindSecurityGroupToSpacesArgsForCall)] - fake.bindSecurityGroupToSpacesArgsForCall = append(fake.bindSecurityGroupToSpacesArgsForCall, struct { - arg1 string - arg2 []resources.Space - arg3 constanta.SecurityGroupLifecycle - }{arg1, arg2Copy, arg3}) + fake.bindSecurityGroupToSpacesArgsForCall = append(fake.bindSecurityGroupToSpacesArgsForCall, FakeActorBindSecurityGroupToSpacesArgs{arg1, arg2Copy, arg3}) stub := fake.BindSecurityGroupToSpacesStub fakeReturns := fake.bindSecurityGroupToSpacesReturns fake.recordInvocation("BindSecurityGroupToSpaces", []interface{}{arg1, arg2Copy, arg3}) @@ -4259,7 +5098,15 @@ func (fake *FakeActor) BindSecurityGroupToSpacesArgsForCall(i int) (string, []re fake.bindSecurityGroupToSpacesMutex.RLock() defer fake.bindSecurityGroupToSpacesMutex.RUnlock() argsForCall := fake.bindSecurityGroupToSpacesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) BindSecurityGroupToSpacesArgs() []FakeActorBindSecurityGroupToSpacesArgs { + fake.bindSecurityGroupToSpacesMutex.RLock() + defer fake.bindSecurityGroupToSpacesMutex.RUnlock() + args := make([]FakeActorBindSecurityGroupToSpacesArgs, len(fake.bindSecurityGroupToSpacesArgsForCall)) + copy(args, fake.bindSecurityGroupToSpacesArgsForCall) + return args } func (fake *FakeActor) BindSecurityGroupToSpacesReturns(result1 v7action.Warnings, result2 error) { @@ -4288,12 +5135,80 @@ func (fake *FakeActor) BindSecurityGroupToSpacesReturnsOnCall(i int, result1 v7a }{result1, result2} } +func (fake *FakeActor) BindServiceAccountByNameAndSpace(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { + fake.bindServiceAccountByNameAndSpaceMutex.Lock() + ret, specificReturn := fake.bindServiceAccountByNameAndSpaceReturnsOnCall[len(fake.bindServiceAccountByNameAndSpaceArgsForCall)] + fake.bindServiceAccountByNameAndSpaceArgsForCall = append(fake.bindServiceAccountByNameAndSpaceArgsForCall, FakeActorBindServiceAccountByNameAndSpaceArgs{arg1, arg2, arg3}) + stub := fake.BindServiceAccountByNameAndSpaceStub + fakeReturns := fake.bindServiceAccountByNameAndSpaceReturns + fake.recordInvocation("BindServiceAccountByNameAndSpace", []interface{}{arg1, arg2, arg3}) + fake.bindServiceAccountByNameAndSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceCallCount() int { + fake.bindServiceAccountByNameAndSpaceMutex.RLock() + defer fake.bindServiceAccountByNameAndSpaceMutex.RUnlock() + return len(fake.bindServiceAccountByNameAndSpaceArgsForCall) +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceCalls(stub func(string, string, string) (v7action.Warnings, error)) { + fake.bindServiceAccountByNameAndSpaceMutex.Lock() + defer fake.bindServiceAccountByNameAndSpaceMutex.Unlock() + fake.BindServiceAccountByNameAndSpaceStub = stub +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceArgsForCall(i int) (string, string, string) { + fake.bindServiceAccountByNameAndSpaceMutex.RLock() + defer fake.bindServiceAccountByNameAndSpaceMutex.RUnlock() + argsForCall := fake.bindServiceAccountByNameAndSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceArgs() []FakeActorBindServiceAccountByNameAndSpaceArgs { + fake.bindServiceAccountByNameAndSpaceMutex.RLock() + defer fake.bindServiceAccountByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorBindServiceAccountByNameAndSpaceArgs, len(fake.bindServiceAccountByNameAndSpaceArgsForCall)) + copy(args, fake.bindServiceAccountByNameAndSpaceArgsForCall) + return args +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { + fake.bindServiceAccountByNameAndSpaceMutex.Lock() + defer fake.bindServiceAccountByNameAndSpaceMutex.Unlock() + fake.BindServiceAccountByNameAndSpaceStub = nil + fake.bindServiceAccountByNameAndSpaceReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) BindServiceAccountByNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.bindServiceAccountByNameAndSpaceMutex.Lock() + defer fake.bindServiceAccountByNameAndSpaceMutex.Unlock() + fake.BindServiceAccountByNameAndSpaceStub = nil + if fake.bindServiceAccountByNameAndSpaceReturnsOnCall == nil { + fake.bindServiceAccountByNameAndSpaceReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.bindServiceAccountByNameAndSpaceReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + func (fake *FakeActor) CancelDeployment(arg1 string) (v7action.Warnings, error) { fake.cancelDeploymentMutex.Lock() ret, specificReturn := fake.cancelDeploymentReturnsOnCall[len(fake.cancelDeploymentArgsForCall)] - fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, struct { - arg1 string - }{arg1}) + fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, FakeActorCancelDeploymentArgs{arg1}) stub := fake.CancelDeploymentStub fakeReturns := fake.cancelDeploymentReturns fake.recordInvocation("CancelDeployment", []interface{}{arg1}) @@ -4323,7 +5238,15 @@ func (fake *FakeActor) CancelDeploymentArgsForCall(i int) string { fake.cancelDeploymentMutex.RLock() defer fake.cancelDeploymentMutex.RUnlock() argsForCall := fake.cancelDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CancelDeploymentArgs() []FakeActorCancelDeploymentArgs { + fake.cancelDeploymentMutex.RLock() + defer fake.cancelDeploymentMutex.RUnlock() + args := make([]FakeActorCancelDeploymentArgs, len(fake.cancelDeploymentArgsForCall)) + copy(args, fake.cancelDeploymentArgsForCall) + return args } func (fake *FakeActor) CancelDeploymentReturns(result1 v7action.Warnings, result2 error) { @@ -4355,12 +5278,7 @@ func (fake *FakeActor) CancelDeploymentReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) CheckRoute(arg1 string, arg2 string, arg3 string, arg4 int) (bool, v7action.Warnings, error) { fake.checkRouteMutex.Lock() ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)] - fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, FakeActorCheckRouteArgs{arg1, arg2, arg3, arg4}) stub := fake.CheckRouteStub fakeReturns := fake.checkRouteReturns fake.recordInvocation("CheckRoute", []interface{}{arg1, arg2, arg3, arg4}) @@ -4390,7 +5308,15 @@ func (fake *FakeActor) CheckRouteArgsForCall(i int) (string, string, string, int fake.checkRouteMutex.RLock() defer fake.checkRouteMutex.RUnlock() argsForCall := fake.checkRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) CheckRouteArgs() []FakeActorCheckRouteArgs { + fake.checkRouteMutex.RLock() + defer fake.checkRouteMutex.RUnlock() + args := make([]FakeActorCheckRouteArgs, len(fake.checkRouteArgsForCall)) + copy(args, fake.checkRouteArgsForCall) + return args } func (fake *FakeActor) CheckRouteReturns(result1 bool, result2 v7action.Warnings, result3 error) { @@ -4424,13 +5350,12 @@ func (fake *FakeActor) CheckRouteReturnsOnCall(i int, result1 bool, result2 v7ac func (fake *FakeActor) ClearTarget() { fake.clearTargetMutex.Lock() - fake.clearTargetArgsForCall = append(fake.clearTargetArgsForCall, struct { - }{}) + fake.clearTargetArgsForCall = append(fake.clearTargetArgsForCall, struct{}{}) stub := fake.ClearTargetStub fake.recordInvocation("ClearTarget", []interface{}{}) fake.clearTargetMutex.Unlock() if stub != nil { - fake.ClearTargetStub() + stub() } } @@ -4449,9 +5374,7 @@ func (fake *FakeActor) ClearTargetCalls(stub func()) { func (fake *FakeActor) ContinueDeployment(arg1 string) (v7action.Warnings, error) { fake.continueDeploymentMutex.Lock() ret, specificReturn := fake.continueDeploymentReturnsOnCall[len(fake.continueDeploymentArgsForCall)] - fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, struct { - arg1 string - }{arg1}) + fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, FakeActorContinueDeploymentArgs{arg1}) stub := fake.ContinueDeploymentStub fakeReturns := fake.continueDeploymentReturns fake.recordInvocation("ContinueDeployment", []interface{}{arg1}) @@ -4481,7 +5404,15 @@ func (fake *FakeActor) ContinueDeploymentArgsForCall(i int) string { fake.continueDeploymentMutex.RLock() defer fake.continueDeploymentMutex.RUnlock() argsForCall := fake.continueDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ContinueDeploymentArgs() []FakeActorContinueDeploymentArgs { + fake.continueDeploymentMutex.RLock() + defer fake.continueDeploymentMutex.RUnlock() + args := make([]FakeActorContinueDeploymentArgs, len(fake.continueDeploymentArgsForCall)) + copy(args, fake.continueDeploymentArgsForCall) + return args } func (fake *FakeActor) ContinueDeploymentReturns(result1 v7action.Warnings, result2 error) { @@ -4513,10 +5444,7 @@ func (fake *FakeActor) ContinueDeploymentReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) CopyPackage(arg1 resources.Application, arg2 resources.Application) (resources.Package, v7action.Warnings, error) { fake.copyPackageMutex.Lock() ret, specificReturn := fake.copyPackageReturnsOnCall[len(fake.copyPackageArgsForCall)] - fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, struct { - arg1 resources.Application - arg2 resources.Application - }{arg1, arg2}) + fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, FakeActorCopyPackageArgs{arg1, arg2}) stub := fake.CopyPackageStub fakeReturns := fake.copyPackageReturns fake.recordInvocation("CopyPackage", []interface{}{arg1, arg2}) @@ -4546,7 +5474,15 @@ func (fake *FakeActor) CopyPackageArgsForCall(i int) (resources.Application, res fake.copyPackageMutex.RLock() defer fake.copyPackageMutex.RUnlock() argsForCall := fake.copyPackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CopyPackageArgs() []FakeActorCopyPackageArgs { + fake.copyPackageMutex.RLock() + defer fake.copyPackageMutex.RUnlock() + args := make([]FakeActorCopyPackageArgs, len(fake.copyPackageArgsForCall)) + copy(args, fake.copyPackageArgsForCall) + return args } func (fake *FakeActor) CopyPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -4581,11 +5517,7 @@ func (fake *FakeActor) CopyPackageReturnsOnCall(i int, result1 resources.Package func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (resources.Package, v7action.Warnings, error) { fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall[len(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall)] - fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall = append(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall = append(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall, FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub fakeReturns := fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturns fake.recordInvocation("CreateAndUploadBitsPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -4615,7 +5547,15 @@ func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceArgsFo fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RLock() defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceArgs() []FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs { + fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RLock() + defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorCreateAndUploadBitsPackageByApplicationNameAndSpaceArgs, len(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -4650,9 +5590,7 @@ func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceReturn func (fake *FakeActor) CreateApplicationDroplet(arg1 string) (resources.Droplet, v7action.Warnings, error) { fake.createApplicationDropletMutex.Lock() ret, specificReturn := fake.createApplicationDropletReturnsOnCall[len(fake.createApplicationDropletArgsForCall)] - fake.createApplicationDropletArgsForCall = append(fake.createApplicationDropletArgsForCall, struct { - arg1 string - }{arg1}) + fake.createApplicationDropletArgsForCall = append(fake.createApplicationDropletArgsForCall, FakeActorCreateApplicationDropletArgs{arg1}) stub := fake.CreateApplicationDropletStub fakeReturns := fake.createApplicationDropletReturns fake.recordInvocation("CreateApplicationDroplet", []interface{}{arg1}) @@ -4682,7 +5620,15 @@ func (fake *FakeActor) CreateApplicationDropletArgsForCall(i int) string { fake.createApplicationDropletMutex.RLock() defer fake.createApplicationDropletMutex.RUnlock() argsForCall := fake.createApplicationDropletArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateApplicationDropletArgs() []FakeActorCreateApplicationDropletArgs { + fake.createApplicationDropletMutex.RLock() + defer fake.createApplicationDropletMutex.RUnlock() + args := make([]FakeActorCreateApplicationDropletArgs, len(fake.createApplicationDropletArgsForCall)) + copy(args, fake.createApplicationDropletArgsForCall) + return args } func (fake *FakeActor) CreateApplicationDropletReturns(result1 resources.Droplet, result2 v7action.Warnings, result3 error) { @@ -4717,10 +5663,7 @@ func (fake *FakeActor) CreateApplicationDropletReturnsOnCall(i int, result1 reso func (fake *FakeActor) CreateApplicationInSpace(arg1 resources.Application, arg2 string) (resources.Application, v7action.Warnings, error) { fake.createApplicationInSpaceMutex.Lock() ret, specificReturn := fake.createApplicationInSpaceReturnsOnCall[len(fake.createApplicationInSpaceArgsForCall)] - fake.createApplicationInSpaceArgsForCall = append(fake.createApplicationInSpaceArgsForCall, struct { - arg1 resources.Application - arg2 string - }{arg1, arg2}) + fake.createApplicationInSpaceArgsForCall = append(fake.createApplicationInSpaceArgsForCall, FakeActorCreateApplicationInSpaceArgs{arg1, arg2}) stub := fake.CreateApplicationInSpaceStub fakeReturns := fake.createApplicationInSpaceReturns fake.recordInvocation("CreateApplicationInSpace", []interface{}{arg1, arg2}) @@ -4750,7 +5693,15 @@ func (fake *FakeActor) CreateApplicationInSpaceArgsForCall(i int) (resources.App fake.createApplicationInSpaceMutex.RLock() defer fake.createApplicationInSpaceMutex.RUnlock() argsForCall := fake.createApplicationInSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CreateApplicationInSpaceArgs() []FakeActorCreateApplicationInSpaceArgs { + fake.createApplicationInSpaceMutex.RLock() + defer fake.createApplicationInSpaceMutex.RUnlock() + args := make([]FakeActorCreateApplicationInSpaceArgs, len(fake.createApplicationInSpaceArgsForCall)) + copy(args, fake.createApplicationInSpaceArgsForCall) + return args } func (fake *FakeActor) CreateApplicationInSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) { @@ -4785,9 +5736,7 @@ func (fake *FakeActor) CreateApplicationInSpaceReturnsOnCall(i int, result1 reso func (fake *FakeActor) CreateBitsPackageByApplication(arg1 string) (resources.Package, v7action.Warnings, error) { fake.createBitsPackageByApplicationMutex.Lock() ret, specificReturn := fake.createBitsPackageByApplicationReturnsOnCall[len(fake.createBitsPackageByApplicationArgsForCall)] - fake.createBitsPackageByApplicationArgsForCall = append(fake.createBitsPackageByApplicationArgsForCall, struct { - arg1 string - }{arg1}) + fake.createBitsPackageByApplicationArgsForCall = append(fake.createBitsPackageByApplicationArgsForCall, FakeActorCreateBitsPackageByApplicationArgs{arg1}) stub := fake.CreateBitsPackageByApplicationStub fakeReturns := fake.createBitsPackageByApplicationReturns fake.recordInvocation("CreateBitsPackageByApplication", []interface{}{arg1}) @@ -4817,7 +5766,15 @@ func (fake *FakeActor) CreateBitsPackageByApplicationArgsForCall(i int) string { fake.createBitsPackageByApplicationMutex.RLock() defer fake.createBitsPackageByApplicationMutex.RUnlock() argsForCall := fake.createBitsPackageByApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateBitsPackageByApplicationArgs() []FakeActorCreateBitsPackageByApplicationArgs { + fake.createBitsPackageByApplicationMutex.RLock() + defer fake.createBitsPackageByApplicationMutex.RUnlock() + args := make([]FakeActorCreateBitsPackageByApplicationArgs, len(fake.createBitsPackageByApplicationArgsForCall)) + copy(args, fake.createBitsPackageByApplicationArgsForCall) + return args } func (fake *FakeActor) CreateBitsPackageByApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -4852,9 +5809,7 @@ func (fake *FakeActor) CreateBitsPackageByApplicationReturnsOnCall(i int, result func (fake *FakeActor) CreateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) { fake.createBuildpackMutex.Lock() ret, specificReturn := fake.createBuildpackReturnsOnCall[len(fake.createBuildpackArgsForCall)] - fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, struct { - arg1 resources.Buildpack - }{arg1}) + fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, FakeActorCreateBuildpackArgs{arg1}) stub := fake.CreateBuildpackStub fakeReturns := fake.createBuildpackReturns fake.recordInvocation("CreateBuildpack", []interface{}{arg1}) @@ -4884,7 +5839,15 @@ func (fake *FakeActor) CreateBuildpackArgsForCall(i int) resources.Buildpack { fake.createBuildpackMutex.RLock() defer fake.createBuildpackMutex.RUnlock() argsForCall := fake.createBuildpackArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateBuildpackArgs() []FakeActorCreateBuildpackArgs { + fake.createBuildpackMutex.RLock() + defer fake.createBuildpackMutex.RUnlock() + args := make([]FakeActorCreateBuildpackArgs, len(fake.createBuildpackArgsForCall)) + copy(args, fake.createBuildpackArgsForCall) + return args } func (fake *FakeActor) CreateBuildpackReturns(result1 resources.Buildpack, result2 v7action.Warnings, result3 error) { @@ -4919,9 +5882,7 @@ func (fake *FakeActor) CreateBuildpackReturnsOnCall(i int, result1 resources.Bui func (fake *FakeActor) CreateDeployment(arg1 resources.Deployment) (string, v7action.Warnings, error) { fake.createDeploymentMutex.Lock() ret, specificReturn := fake.createDeploymentReturnsOnCall[len(fake.createDeploymentArgsForCall)] - fake.createDeploymentArgsForCall = append(fake.createDeploymentArgsForCall, struct { - arg1 resources.Deployment - }{arg1}) + fake.createDeploymentArgsForCall = append(fake.createDeploymentArgsForCall, FakeActorCreateDeploymentArgs{arg1}) stub := fake.CreateDeploymentStub fakeReturns := fake.createDeploymentReturns fake.recordInvocation("CreateDeployment", []interface{}{arg1}) @@ -4951,7 +5912,15 @@ func (fake *FakeActor) CreateDeploymentArgsForCall(i int) resources.Deployment { fake.createDeploymentMutex.RLock() defer fake.createDeploymentMutex.RUnlock() argsForCall := fake.createDeploymentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateDeploymentArgs() []FakeActorCreateDeploymentArgs { + fake.createDeploymentMutex.RLock() + defer fake.createDeploymentMutex.RUnlock() + args := make([]FakeActorCreateDeploymentArgs, len(fake.createDeploymentArgsForCall)) + copy(args, fake.createDeploymentArgsForCall) + return args } func (fake *FakeActor) CreateDeploymentReturns(result1 string, result2 v7action.Warnings, result3 error) { @@ -4986,10 +5955,7 @@ func (fake *FakeActor) CreateDeploymentReturnsOnCall(i int, result1 string, resu func (fake *FakeActor) CreateDockerPackageByApplication(arg1 string, arg2 v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) { fake.createDockerPackageByApplicationMutex.Lock() ret, specificReturn := fake.createDockerPackageByApplicationReturnsOnCall[len(fake.createDockerPackageByApplicationArgsForCall)] - fake.createDockerPackageByApplicationArgsForCall = append(fake.createDockerPackageByApplicationArgsForCall, struct { - arg1 string - arg2 v7action.DockerImageCredentials - }{arg1, arg2}) + fake.createDockerPackageByApplicationArgsForCall = append(fake.createDockerPackageByApplicationArgsForCall, FakeActorCreateDockerPackageByApplicationArgs{arg1, arg2}) stub := fake.CreateDockerPackageByApplicationStub fakeReturns := fake.createDockerPackageByApplicationReturns fake.recordInvocation("CreateDockerPackageByApplication", []interface{}{arg1, arg2}) @@ -5019,7 +5985,15 @@ func (fake *FakeActor) CreateDockerPackageByApplicationArgsForCall(i int) (strin fake.createDockerPackageByApplicationMutex.RLock() defer fake.createDockerPackageByApplicationMutex.RUnlock() argsForCall := fake.createDockerPackageByApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CreateDockerPackageByApplicationArgs() []FakeActorCreateDockerPackageByApplicationArgs { + fake.createDockerPackageByApplicationMutex.RLock() + defer fake.createDockerPackageByApplicationMutex.RUnlock() + args := make([]FakeActorCreateDockerPackageByApplicationArgs, len(fake.createDockerPackageByApplicationArgsForCall)) + copy(args, fake.createDockerPackageByApplicationArgsForCall) + return args } func (fake *FakeActor) CreateDockerPackageByApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -5054,11 +6028,7 @@ func (fake *FakeActor) CreateDockerPackageByApplicationReturnsOnCall(i int, resu func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpace(arg1 string, arg2 string, arg3 v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) { fake.createDockerPackageByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.createDockerPackageByApplicationNameAndSpaceReturnsOnCall[len(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall)] - fake.createDockerPackageByApplicationNameAndSpaceArgsForCall = append(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.DockerImageCredentials - }{arg1, arg2, arg3}) + fake.createDockerPackageByApplicationNameAndSpaceArgsForCall = append(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall, FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.CreateDockerPackageByApplicationNameAndSpaceStub fakeReturns := fake.createDockerPackageByApplicationNameAndSpaceReturns fake.recordInvocation("CreateDockerPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -5088,7 +6058,15 @@ func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceArgsForCall(i fake.createDockerPackageByApplicationNameAndSpaceMutex.RLock() defer fake.createDockerPackageByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.createDockerPackageByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceArgs() []FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs { + fake.createDockerPackageByApplicationNameAndSpaceMutex.RLock() + defer fake.createDockerPackageByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorCreateDockerPackageByApplicationNameAndSpaceArgs, len(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.createDockerPackageByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -5123,9 +6101,7 @@ func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceReturnsOnCall func (fake *FakeActor) CreateIsolationSegmentByName(arg1 resources.IsolationSegment) (v7action.Warnings, error) { fake.createIsolationSegmentByNameMutex.Lock() ret, specificReturn := fake.createIsolationSegmentByNameReturnsOnCall[len(fake.createIsolationSegmentByNameArgsForCall)] - fake.createIsolationSegmentByNameArgsForCall = append(fake.createIsolationSegmentByNameArgsForCall, struct { - arg1 resources.IsolationSegment - }{arg1}) + fake.createIsolationSegmentByNameArgsForCall = append(fake.createIsolationSegmentByNameArgsForCall, FakeActorCreateIsolationSegmentByNameArgs{arg1}) stub := fake.CreateIsolationSegmentByNameStub fakeReturns := fake.createIsolationSegmentByNameReturns fake.recordInvocation("CreateIsolationSegmentByName", []interface{}{arg1}) @@ -5155,7 +6131,15 @@ func (fake *FakeActor) CreateIsolationSegmentByNameArgsForCall(i int) resources. fake.createIsolationSegmentByNameMutex.RLock() defer fake.createIsolationSegmentByNameMutex.RUnlock() argsForCall := fake.createIsolationSegmentByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateIsolationSegmentByNameArgs() []FakeActorCreateIsolationSegmentByNameArgs { + fake.createIsolationSegmentByNameMutex.RLock() + defer fake.createIsolationSegmentByNameMutex.RUnlock() + args := make([]FakeActorCreateIsolationSegmentByNameArgs, len(fake.createIsolationSegmentByNameArgsForCall)) + copy(args, fake.createIsolationSegmentByNameArgsForCall) + return args } func (fake *FakeActor) CreateIsolationSegmentByNameReturns(result1 v7action.Warnings, result2 error) { @@ -5187,9 +6171,7 @@ func (fake *FakeActor) CreateIsolationSegmentByNameReturnsOnCall(i int, result1 func (fake *FakeActor) CreateManagedServiceInstance(arg1 v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.createManagedServiceInstanceMutex.Lock() ret, specificReturn := fake.createManagedServiceInstanceReturnsOnCall[len(fake.createManagedServiceInstanceArgsForCall)] - fake.createManagedServiceInstanceArgsForCall = append(fake.createManagedServiceInstanceArgsForCall, struct { - arg1 v7action.CreateManagedServiceInstanceParams - }{arg1}) + fake.createManagedServiceInstanceArgsForCall = append(fake.createManagedServiceInstanceArgsForCall, FakeActorCreateManagedServiceInstanceArgs{arg1}) stub := fake.CreateManagedServiceInstanceStub fakeReturns := fake.createManagedServiceInstanceReturns fake.recordInvocation("CreateManagedServiceInstance", []interface{}{arg1}) @@ -5219,7 +6201,15 @@ func (fake *FakeActor) CreateManagedServiceInstanceArgsForCall(i int) v7action.C fake.createManagedServiceInstanceMutex.RLock() defer fake.createManagedServiceInstanceMutex.RUnlock() argsForCall := fake.createManagedServiceInstanceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateManagedServiceInstanceArgs() []FakeActorCreateManagedServiceInstanceArgs { + fake.createManagedServiceInstanceMutex.RLock() + defer fake.createManagedServiceInstanceMutex.RUnlock() + args := make([]FakeActorCreateManagedServiceInstanceArgs, len(fake.createManagedServiceInstanceArgsForCall)) + copy(args, fake.createManagedServiceInstanceArgsForCall) + return args } func (fake *FakeActor) CreateManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -5254,13 +6244,7 @@ func (fake *FakeActor) CreateManagedServiceInstanceReturnsOnCall(i int, result1 func (fake *FakeActor) CreateOrgRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) { fake.createOrgRoleMutex.Lock() ret, specificReturn := fake.createOrgRoleReturnsOnCall[len(fake.createOrgRoleArgsForCall)] - fake.createOrgRoleArgsForCall = append(fake.createOrgRoleArgsForCall, struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + fake.createOrgRoleArgsForCall = append(fake.createOrgRoleArgsForCall, FakeActorCreateOrgRoleArgs{arg1, arg2, arg3, arg4, arg5}) stub := fake.CreateOrgRoleStub fakeReturns := fake.createOrgRoleReturns fake.recordInvocation("CreateOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5}) @@ -5290,7 +6274,15 @@ func (fake *FakeActor) CreateOrgRoleArgsForCall(i int) (constanta.RoleType, stri fake.createOrgRoleMutex.RLock() defer fake.createOrgRoleMutex.RUnlock() argsForCall := fake.createOrgRoleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) CreateOrgRoleArgs() []FakeActorCreateOrgRoleArgs { + fake.createOrgRoleMutex.RLock() + defer fake.createOrgRoleMutex.RUnlock() + args := make([]FakeActorCreateOrgRoleArgs, len(fake.createOrgRoleArgsForCall)) + copy(args, fake.createOrgRoleArgsForCall) + return args } func (fake *FakeActor) CreateOrgRoleReturns(result1 v7action.Warnings, result2 error) { @@ -5322,9 +6314,7 @@ func (fake *FakeActor) CreateOrgRoleReturnsOnCall(i int, result1 v7action.Warnin func (fake *FakeActor) CreateOrganization(arg1 string) (resources.Organization, v7action.Warnings, error) { fake.createOrganizationMutex.Lock() ret, specificReturn := fake.createOrganizationReturnsOnCall[len(fake.createOrganizationArgsForCall)] - fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, FakeActorCreateOrganizationArgs{arg1}) stub := fake.CreateOrganizationStub fakeReturns := fake.createOrganizationReturns fake.recordInvocation("CreateOrganization", []interface{}{arg1}) @@ -5354,7 +6344,15 @@ func (fake *FakeActor) CreateOrganizationArgsForCall(i int) string { fake.createOrganizationMutex.RLock() defer fake.createOrganizationMutex.RUnlock() argsForCall := fake.createOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateOrganizationArgs() []FakeActorCreateOrganizationArgs { + fake.createOrganizationMutex.RLock() + defer fake.createOrganizationMutex.RUnlock() + args := make([]FakeActorCreateOrganizationArgs, len(fake.createOrganizationArgsForCall)) + copy(args, fake.createOrganizationArgsForCall) + return args } func (fake *FakeActor) CreateOrganizationReturns(result1 resources.Organization, result2 v7action.Warnings, result3 error) { @@ -5389,10 +6387,7 @@ func (fake *FakeActor) CreateOrganizationReturnsOnCall(i int, result1 resources. func (fake *FakeActor) CreateOrganizationQuota(arg1 string, arg2 v7action.QuotaLimits) (v7action.Warnings, error) { fake.createOrganizationQuotaMutex.Lock() ret, specificReturn := fake.createOrganizationQuotaReturnsOnCall[len(fake.createOrganizationQuotaArgsForCall)] - fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, struct { - arg1 string - arg2 v7action.QuotaLimits - }{arg1, arg2}) + fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, FakeActorCreateOrganizationQuotaArgs{arg1, arg2}) stub := fake.CreateOrganizationQuotaStub fakeReturns := fake.createOrganizationQuotaReturns fake.recordInvocation("CreateOrganizationQuota", []interface{}{arg1, arg2}) @@ -5422,7 +6417,15 @@ func (fake *FakeActor) CreateOrganizationQuotaArgsForCall(i int) (string, v7acti fake.createOrganizationQuotaMutex.RLock() defer fake.createOrganizationQuotaMutex.RUnlock() argsForCall := fake.createOrganizationQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CreateOrganizationQuotaArgs() []FakeActorCreateOrganizationQuotaArgs { + fake.createOrganizationQuotaMutex.RLock() + defer fake.createOrganizationQuotaMutex.RUnlock() + args := make([]FakeActorCreateOrganizationQuotaArgs, len(fake.createOrganizationQuotaArgsForCall)) + copy(args, fake.createOrganizationQuotaArgsForCall) + return args } func (fake *FakeActor) CreateOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -5454,12 +6457,7 @@ func (fake *FakeActor) CreateOrganizationQuotaReturnsOnCall(i int, result1 v7act func (fake *FakeActor) CreatePrivateDomain(arg1 string, arg2 string, arg3 bool, arg4 string) (v7action.Warnings, error) { fake.createPrivateDomainMutex.Lock() ret, specificReturn := fake.createPrivateDomainReturnsOnCall[len(fake.createPrivateDomainArgsForCall)] - fake.createPrivateDomainArgsForCall = append(fake.createPrivateDomainArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.createPrivateDomainArgsForCall = append(fake.createPrivateDomainArgsForCall, FakeActorCreatePrivateDomainArgs{arg1, arg2, arg3, arg4}) stub := fake.CreatePrivateDomainStub fakeReturns := fake.createPrivateDomainReturns fake.recordInvocation("CreatePrivateDomain", []interface{}{arg1, arg2, arg3, arg4}) @@ -5489,7 +6487,15 @@ func (fake *FakeActor) CreatePrivateDomainArgsForCall(i int) (string, string, bo fake.createPrivateDomainMutex.RLock() defer fake.createPrivateDomainMutex.RUnlock() argsForCall := fake.createPrivateDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) CreatePrivateDomainArgs() []FakeActorCreatePrivateDomainArgs { + fake.createPrivateDomainMutex.RLock() + defer fake.createPrivateDomainMutex.RUnlock() + args := make([]FakeActorCreatePrivateDomainArgs, len(fake.createPrivateDomainArgsForCall)) + copy(args, fake.createPrivateDomainArgsForCall) + return args } func (fake *FakeActor) CreatePrivateDomainReturns(result1 v7action.Warnings, result2 error) { @@ -5521,14 +6527,7 @@ func (fake *FakeActor) CreatePrivateDomainReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) CreateRoute(arg1 string, arg2 string, arg3 string, arg4 string, arg5 int, arg6 map[string]*string) (resources.Route, v7action.Warnings, error) { fake.createRouteMutex.Lock() ret, specificReturn := fake.createRouteReturnsOnCall[len(fake.createRouteArgsForCall)] - fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - arg5 int - arg6 map[string]*string - }{arg1, arg2, arg3, arg4, arg5, arg6}) + fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, FakeActorCreateRouteArgs{arg1, arg2, arg3, arg4, arg5, arg6}) stub := fake.CreateRouteStub fakeReturns := fake.createRouteReturns fake.recordInvocation("CreateRoute", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) @@ -5558,7 +6557,15 @@ func (fake *FakeActor) CreateRouteArgsForCall(i int) (string, string, string, st fake.createRouteMutex.RLock() defer fake.createRouteMutex.RUnlock() argsForCall := fake.createRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5, argsForCall.Arg6 +} + +func (fake *FakeActor) CreateRouteArgs() []FakeActorCreateRouteArgs { + fake.createRouteMutex.RLock() + defer fake.createRouteMutex.RUnlock() + args := make([]FakeActorCreateRouteArgs, len(fake.createRouteArgsForCall)) + copy(args, fake.createRouteArgsForCall) + return args } func (fake *FakeActor) CreateRouteReturns(result1 resources.Route, result2 v7action.Warnings, result3 error) { @@ -5593,9 +6600,7 @@ func (fake *FakeActor) CreateRouteReturnsOnCall(i int, result1 resources.Route, func (fake *FakeActor) CreateRouteBinding(arg1 v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.createRouteBindingMutex.Lock() ret, specificReturn := fake.createRouteBindingReturnsOnCall[len(fake.createRouteBindingArgsForCall)] - fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, struct { - arg1 v7action.CreateRouteBindingParams - }{arg1}) + fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, FakeActorCreateRouteBindingArgs{arg1}) stub := fake.CreateRouteBindingStub fakeReturns := fake.createRouteBindingReturns fake.recordInvocation("CreateRouteBinding", []interface{}{arg1}) @@ -5625,7 +6630,15 @@ func (fake *FakeActor) CreateRouteBindingArgsForCall(i int) v7action.CreateRoute fake.createRouteBindingMutex.RLock() defer fake.createRouteBindingMutex.RUnlock() argsForCall := fake.createRouteBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateRouteBindingArgs() []FakeActorCreateRouteBindingArgs { + fake.createRouteBindingMutex.RLock() + defer fake.createRouteBindingMutex.RUnlock() + args := make([]FakeActorCreateRouteBindingArgs, len(fake.createRouteBindingArgsForCall)) + copy(args, fake.createRouteBindingArgsForCall) + return args } func (fake *FakeActor) CreateRouteBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -5660,10 +6673,7 @@ func (fake *FakeActor) CreateRouteBindingReturnsOnCall(i int, result1 chan v7act func (fake *FakeActor) CreateSecurityGroup(arg1 string, arg2 string) (v7action.Warnings, error) { fake.createSecurityGroupMutex.Lock() ret, specificReturn := fake.createSecurityGroupReturnsOnCall[len(fake.createSecurityGroupArgsForCall)] - fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, FakeActorCreateSecurityGroupArgs{arg1, arg2}) stub := fake.CreateSecurityGroupStub fakeReturns := fake.createSecurityGroupReturns fake.recordInvocation("CreateSecurityGroup", []interface{}{arg1, arg2}) @@ -5693,7 +6703,15 @@ func (fake *FakeActor) CreateSecurityGroupArgsForCall(i int) (string, string) { fake.createSecurityGroupMutex.RLock() defer fake.createSecurityGroupMutex.RUnlock() argsForCall := fake.createSecurityGroupArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CreateSecurityGroupArgs() []FakeActorCreateSecurityGroupArgs { + fake.createSecurityGroupMutex.RLock() + defer fake.createSecurityGroupMutex.RUnlock() + args := make([]FakeActorCreateSecurityGroupArgs, len(fake.createSecurityGroupArgsForCall)) + copy(args, fake.createSecurityGroupArgsForCall) + return args } func (fake *FakeActor) CreateSecurityGroupReturns(result1 v7action.Warnings, result2 error) { @@ -5722,12 +6740,83 @@ func (fake *FakeActor) CreateSecurityGroupReturnsOnCall(i int, result1 v7action. }{result1, result2} } +func (fake *FakeActor) CreateServiceAccountInSpace(arg1 string, arg2 string, arg3 string) (resources.ServiceAccount, v7action.Warnings, error) { + fake.createServiceAccountInSpaceMutex.Lock() + ret, specificReturn := fake.createServiceAccountInSpaceReturnsOnCall[len(fake.createServiceAccountInSpaceArgsForCall)] + fake.createServiceAccountInSpaceArgsForCall = append(fake.createServiceAccountInSpaceArgsForCall, FakeActorCreateServiceAccountInSpaceArgs{arg1, arg2, arg3}) + stub := fake.CreateServiceAccountInSpaceStub + fakeReturns := fake.createServiceAccountInSpaceReturns + fake.recordInvocation("CreateServiceAccountInSpace", []interface{}{arg1, arg2, arg3}) + fake.createServiceAccountInSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeActor) CreateServiceAccountInSpaceCallCount() int { + fake.createServiceAccountInSpaceMutex.RLock() + defer fake.createServiceAccountInSpaceMutex.RUnlock() + return len(fake.createServiceAccountInSpaceArgsForCall) +} + +func (fake *FakeActor) CreateServiceAccountInSpaceCalls(stub func(string, string, string) (resources.ServiceAccount, v7action.Warnings, error)) { + fake.createServiceAccountInSpaceMutex.Lock() + defer fake.createServiceAccountInSpaceMutex.Unlock() + fake.CreateServiceAccountInSpaceStub = stub +} + +func (fake *FakeActor) CreateServiceAccountInSpaceArgsForCall(i int) (string, string, string) { + fake.createServiceAccountInSpaceMutex.RLock() + defer fake.createServiceAccountInSpaceMutex.RUnlock() + argsForCall := fake.createServiceAccountInSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) CreateServiceAccountInSpaceArgs() []FakeActorCreateServiceAccountInSpaceArgs { + fake.createServiceAccountInSpaceMutex.RLock() + defer fake.createServiceAccountInSpaceMutex.RUnlock() + args := make([]FakeActorCreateServiceAccountInSpaceArgs, len(fake.createServiceAccountInSpaceArgsForCall)) + copy(args, fake.createServiceAccountInSpaceArgsForCall) + return args +} + +func (fake *FakeActor) CreateServiceAccountInSpaceReturns(result1 resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.createServiceAccountInSpaceMutex.Lock() + defer fake.createServiceAccountInSpaceMutex.Unlock() + fake.CreateServiceAccountInSpaceStub = nil + fake.createServiceAccountInSpaceReturns = struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) CreateServiceAccountInSpaceReturnsOnCall(i int, result1 resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.createServiceAccountInSpaceMutex.Lock() + defer fake.createServiceAccountInSpaceMutex.Unlock() + fake.CreateServiceAccountInSpaceStub = nil + if fake.createServiceAccountInSpaceReturnsOnCall == nil { + fake.createServiceAccountInSpaceReturnsOnCall = make(map[int]struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }) + } + fake.createServiceAccountInSpaceReturnsOnCall[i] = struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeActor) CreateServiceAppBinding(arg1 v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.createServiceAppBindingMutex.Lock() ret, specificReturn := fake.createServiceAppBindingReturnsOnCall[len(fake.createServiceAppBindingArgsForCall)] - fake.createServiceAppBindingArgsForCall = append(fake.createServiceAppBindingArgsForCall, struct { - arg1 v7action.CreateServiceAppBindingParams - }{arg1}) + fake.createServiceAppBindingArgsForCall = append(fake.createServiceAppBindingArgsForCall, FakeActorCreateServiceAppBindingArgs{arg1}) stub := fake.CreateServiceAppBindingStub fakeReturns := fake.createServiceAppBindingReturns fake.recordInvocation("CreateServiceAppBinding", []interface{}{arg1}) @@ -5757,7 +6846,15 @@ func (fake *FakeActor) CreateServiceAppBindingArgsForCall(i int) v7action.Create fake.createServiceAppBindingMutex.RLock() defer fake.createServiceAppBindingMutex.RUnlock() argsForCall := fake.createServiceAppBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateServiceAppBindingArgs() []FakeActorCreateServiceAppBindingArgs { + fake.createServiceAppBindingMutex.RLock() + defer fake.createServiceAppBindingMutex.RUnlock() + args := make([]FakeActorCreateServiceAppBindingArgs, len(fake.createServiceAppBindingArgsForCall)) + copy(args, fake.createServiceAppBindingArgsForCall) + return args } func (fake *FakeActor) CreateServiceAppBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -5792,9 +6889,7 @@ func (fake *FakeActor) CreateServiceAppBindingReturnsOnCall(i int, result1 chan func (fake *FakeActor) CreateServiceBroker(arg1 resources.ServiceBroker) (v7action.Warnings, error) { fake.createServiceBrokerMutex.Lock() ret, specificReturn := fake.createServiceBrokerReturnsOnCall[len(fake.createServiceBrokerArgsForCall)] - fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, struct { - arg1 resources.ServiceBroker - }{arg1}) + fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, FakeActorCreateServiceBrokerArgs{arg1}) stub := fake.CreateServiceBrokerStub fakeReturns := fake.createServiceBrokerReturns fake.recordInvocation("CreateServiceBroker", []interface{}{arg1}) @@ -5824,7 +6919,15 @@ func (fake *FakeActor) CreateServiceBrokerArgsForCall(i int) resources.ServiceBr fake.createServiceBrokerMutex.RLock() defer fake.createServiceBrokerMutex.RUnlock() argsForCall := fake.createServiceBrokerArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateServiceBrokerArgs() []FakeActorCreateServiceBrokerArgs { + fake.createServiceBrokerMutex.RLock() + defer fake.createServiceBrokerMutex.RUnlock() + args := make([]FakeActorCreateServiceBrokerArgs, len(fake.createServiceBrokerArgsForCall)) + copy(args, fake.createServiceBrokerArgsForCall) + return args } func (fake *FakeActor) CreateServiceBrokerReturns(result1 v7action.Warnings, result2 error) { @@ -5856,9 +6959,7 @@ func (fake *FakeActor) CreateServiceBrokerReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) CreateServiceKey(arg1 v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.createServiceKeyMutex.Lock() ret, specificReturn := fake.createServiceKeyReturnsOnCall[len(fake.createServiceKeyArgsForCall)] - fake.createServiceKeyArgsForCall = append(fake.createServiceKeyArgsForCall, struct { - arg1 v7action.CreateServiceKeyParams - }{arg1}) + fake.createServiceKeyArgsForCall = append(fake.createServiceKeyArgsForCall, FakeActorCreateServiceKeyArgs{arg1}) stub := fake.CreateServiceKeyStub fakeReturns := fake.createServiceKeyReturns fake.recordInvocation("CreateServiceKey", []interface{}{arg1}) @@ -5888,7 +6989,15 @@ func (fake *FakeActor) CreateServiceKeyArgsForCall(i int) v7action.CreateService fake.createServiceKeyMutex.RLock() defer fake.createServiceKeyMutex.RUnlock() argsForCall := fake.createServiceKeyArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateServiceKeyArgs() []FakeActorCreateServiceKeyArgs { + fake.createServiceKeyMutex.RLock() + defer fake.createServiceKeyMutex.RUnlock() + args := make([]FakeActorCreateServiceKeyArgs, len(fake.createServiceKeyArgsForCall)) + copy(args, fake.createServiceKeyArgsForCall) + return args } func (fake *FakeActor) CreateServiceKeyReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -5923,13 +7032,7 @@ func (fake *FakeActor) CreateServiceKeyReturnsOnCall(i int, result1 chan v7actio func (fake *FakeActor) CreateSharedDomain(arg1 string, arg2 bool, arg3 string, arg4 bool, arg5 string) (v7action.Warnings, error) { fake.createSharedDomainMutex.Lock() ret, specificReturn := fake.createSharedDomainReturnsOnCall[len(fake.createSharedDomainArgsForCall)] - fake.createSharedDomainArgsForCall = append(fake.createSharedDomainArgsForCall, struct { - arg1 string - arg2 bool - arg3 string - arg4 bool - arg5 string - }{arg1, arg2, arg3, arg4, arg5}) + fake.createSharedDomainArgsForCall = append(fake.createSharedDomainArgsForCall, FakeActorCreateSharedDomainArgs{arg1, arg2, arg3, arg4, arg5}) stub := fake.CreateSharedDomainStub fakeReturns := fake.createSharedDomainReturns fake.recordInvocation("CreateSharedDomain", []interface{}{arg1, arg2, arg3, arg4, arg5}) @@ -5959,7 +7062,15 @@ func (fake *FakeActor) CreateSharedDomainArgsForCall(i int) (string, bool, strin fake.createSharedDomainMutex.RLock() defer fake.createSharedDomainMutex.RUnlock() argsForCall := fake.createSharedDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) CreateSharedDomainArgs() []FakeActorCreateSharedDomainArgs { + fake.createSharedDomainMutex.RLock() + defer fake.createSharedDomainMutex.RUnlock() + args := make([]FakeActorCreateSharedDomainArgs, len(fake.createSharedDomainArgsForCall)) + copy(args, fake.createSharedDomainArgsForCall) + return args } func (fake *FakeActor) CreateSharedDomainReturns(result1 v7action.Warnings, result2 error) { @@ -5991,10 +7102,7 @@ func (fake *FakeActor) CreateSharedDomainReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) CreateSpace(arg1 string, arg2 string) (resources.Space, v7action.Warnings, error) { fake.createSpaceMutex.Lock() ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)] - fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, FakeActorCreateSpaceArgs{arg1, arg2}) stub := fake.CreateSpaceStub fakeReturns := fake.createSpaceReturns fake.recordInvocation("CreateSpace", []interface{}{arg1, arg2}) @@ -6024,7 +7132,15 @@ func (fake *FakeActor) CreateSpaceArgsForCall(i int) (string, string) { fake.createSpaceMutex.RLock() defer fake.createSpaceMutex.RUnlock() argsForCall := fake.createSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) CreateSpaceArgs() []FakeActorCreateSpaceArgs { + fake.createSpaceMutex.RLock() + defer fake.createSpaceMutex.RUnlock() + args := make([]FakeActorCreateSpaceArgs, len(fake.createSpaceArgsForCall)) + copy(args, fake.createSpaceArgsForCall) + return args } func (fake *FakeActor) CreateSpaceReturns(result1 resources.Space, result2 v7action.Warnings, result3 error) { @@ -6059,11 +7175,7 @@ func (fake *FakeActor) CreateSpaceReturnsOnCall(i int, result1 resources.Space, func (fake *FakeActor) CreateSpaceQuota(arg1 string, arg2 string, arg3 v7action.QuotaLimits) (v7action.Warnings, error) { fake.createSpaceQuotaMutex.Lock() ret, specificReturn := fake.createSpaceQuotaReturnsOnCall[len(fake.createSpaceQuotaArgsForCall)] - fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.QuotaLimits - }{arg1, arg2, arg3}) + fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, FakeActorCreateSpaceQuotaArgs{arg1, arg2, arg3}) stub := fake.CreateSpaceQuotaStub fakeReturns := fake.createSpaceQuotaReturns fake.recordInvocation("CreateSpaceQuota", []interface{}{arg1, arg2, arg3}) @@ -6093,7 +7205,15 @@ func (fake *FakeActor) CreateSpaceQuotaArgsForCall(i int) (string, string, v7act fake.createSpaceQuotaMutex.RLock() defer fake.createSpaceQuotaMutex.RUnlock() argsForCall := fake.createSpaceQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) CreateSpaceQuotaArgs() []FakeActorCreateSpaceQuotaArgs { + fake.createSpaceQuotaMutex.RLock() + defer fake.createSpaceQuotaMutex.RUnlock() + args := make([]FakeActorCreateSpaceQuotaArgs, len(fake.createSpaceQuotaArgsForCall)) + copy(args, fake.createSpaceQuotaArgsForCall) + return args } func (fake *FakeActor) CreateSpaceQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -6125,14 +7245,7 @@ func (fake *FakeActor) CreateSpaceQuotaReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) CreateSpaceRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 string, arg6 bool) (v7action.Warnings, error) { fake.createSpaceRoleMutex.Lock() ret, specificReturn := fake.createSpaceRoleReturnsOnCall[len(fake.createSpaceRoleArgsForCall)] - fake.createSpaceRoleArgsForCall = append(fake.createSpaceRoleArgsForCall, struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 string - arg6 bool - }{arg1, arg2, arg3, arg4, arg5, arg6}) + fake.createSpaceRoleArgsForCall = append(fake.createSpaceRoleArgsForCall, FakeActorCreateSpaceRoleArgs{arg1, arg2, arg3, arg4, arg5, arg6}) stub := fake.CreateSpaceRoleStub fakeReturns := fake.createSpaceRoleReturns fake.recordInvocation("CreateSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) @@ -6161,8 +7274,16 @@ func (fake *FakeActor) CreateSpaceRoleCalls(stub func(constanta.RoleType, string func (fake *FakeActor) CreateSpaceRoleArgsForCall(i int) (constanta.RoleType, string, string, string, string, bool) { fake.createSpaceRoleMutex.RLock() defer fake.createSpaceRoleMutex.RUnlock() - argsForCall := fake.createSpaceRoleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 + argsForCall := fake.createSpaceRoleArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5, argsForCall.Arg6 +} + +func (fake *FakeActor) CreateSpaceRoleArgs() []FakeActorCreateSpaceRoleArgs { + fake.createSpaceRoleMutex.RLock() + defer fake.createSpaceRoleMutex.RUnlock() + args := make([]FakeActorCreateSpaceRoleArgs, len(fake.createSpaceRoleArgsForCall)) + copy(args, fake.createSpaceRoleArgsForCall) + return args } func (fake *FakeActor) CreateSpaceRoleReturns(result1 v7action.Warnings, result2 error) { @@ -6194,11 +7315,7 @@ func (fake *FakeActor) CreateSpaceRoleReturnsOnCall(i int, result1 v7action.Warn func (fake *FakeActor) CreateUser(arg1 string, arg2 string, arg3 string) (resources.User, v7action.Warnings, error) { fake.createUserMutex.Lock() ret, specificReturn := fake.createUserReturnsOnCall[len(fake.createUserArgsForCall)] - fake.createUserArgsForCall = append(fake.createUserArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.createUserArgsForCall = append(fake.createUserArgsForCall, FakeActorCreateUserArgs{arg1, arg2, arg3}) stub := fake.CreateUserStub fakeReturns := fake.createUserReturns fake.recordInvocation("CreateUser", []interface{}{arg1, arg2, arg3}) @@ -6228,7 +7345,15 @@ func (fake *FakeActor) CreateUserArgsForCall(i int) (string, string, string) { fake.createUserMutex.RLock() defer fake.createUserMutex.RUnlock() argsForCall := fake.createUserArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) CreateUserArgs() []FakeActorCreateUserArgs { + fake.createUserMutex.RLock() + defer fake.createUserMutex.RUnlock() + args := make([]FakeActorCreateUserArgs, len(fake.createUserArgsForCall)) + copy(args, fake.createUserArgsForCall) + return args } func (fake *FakeActor) CreateUserReturns(result1 resources.User, result2 v7action.Warnings, result3 error) { @@ -6263,9 +7388,7 @@ func (fake *FakeActor) CreateUserReturnsOnCall(i int, result1 resources.User, re func (fake *FakeActor) CreateUserProvidedServiceInstance(arg1 resources.ServiceInstance) (v7action.Warnings, error) { fake.createUserProvidedServiceInstanceMutex.Lock() ret, specificReturn := fake.createUserProvidedServiceInstanceReturnsOnCall[len(fake.createUserProvidedServiceInstanceArgsForCall)] - fake.createUserProvidedServiceInstanceArgsForCall = append(fake.createUserProvidedServiceInstanceArgsForCall, struct { - arg1 resources.ServiceInstance - }{arg1}) + fake.createUserProvidedServiceInstanceArgsForCall = append(fake.createUserProvidedServiceInstanceArgsForCall, FakeActorCreateUserProvidedServiceInstanceArgs{arg1}) stub := fake.CreateUserProvidedServiceInstanceStub fakeReturns := fake.createUserProvidedServiceInstanceReturns fake.recordInvocation("CreateUserProvidedServiceInstance", []interface{}{arg1}) @@ -6295,7 +7418,15 @@ func (fake *FakeActor) CreateUserProvidedServiceInstanceArgsForCall(i int) resou fake.createUserProvidedServiceInstanceMutex.RLock() defer fake.createUserProvidedServiceInstanceMutex.RUnlock() argsForCall := fake.createUserProvidedServiceInstanceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) CreateUserProvidedServiceInstanceArgs() []FakeActorCreateUserProvidedServiceInstanceArgs { + fake.createUserProvidedServiceInstanceMutex.RLock() + defer fake.createUserProvidedServiceInstanceMutex.RUnlock() + args := make([]FakeActorCreateUserProvidedServiceInstanceArgs, len(fake.createUserProvidedServiceInstanceArgsForCall)) + copy(args, fake.createUserProvidedServiceInstanceArgsForCall) + return args } func (fake *FakeActor) CreateUserProvidedServiceInstanceReturns(result1 v7action.Warnings, result2 error) { @@ -6327,11 +7458,7 @@ func (fake *FakeActor) CreateUserProvidedServiceInstanceReturnsOnCall(i int, res func (fake *FakeActor) DeleteApplicationByNameAndSpace(arg1 string, arg2 string, arg3 bool) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.deleteApplicationByNameAndSpaceReturnsOnCall[len(fake.deleteApplicationByNameAndSpaceArgsForCall)] - fake.deleteApplicationByNameAndSpaceArgsForCall = append(fake.deleteApplicationByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - }{arg1, arg2, arg3}) + fake.deleteApplicationByNameAndSpaceArgsForCall = append(fake.deleteApplicationByNameAndSpaceArgsForCall, FakeActorDeleteApplicationByNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.DeleteApplicationByNameAndSpaceStub fakeReturns := fake.deleteApplicationByNameAndSpaceReturns fake.recordInvocation("DeleteApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -6361,7 +7488,15 @@ func (fake *FakeActor) DeleteApplicationByNameAndSpaceArgsForCall(i int) (string fake.deleteApplicationByNameAndSpaceMutex.RLock() defer fake.deleteApplicationByNameAndSpaceMutex.RUnlock() argsForCall := fake.deleteApplicationByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) DeleteApplicationByNameAndSpaceArgs() []FakeActorDeleteApplicationByNameAndSpaceArgs { + fake.deleteApplicationByNameAndSpaceMutex.RLock() + defer fake.deleteApplicationByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorDeleteApplicationByNameAndSpaceArgs, len(fake.deleteApplicationByNameAndSpaceArgsForCall)) + copy(args, fake.deleteApplicationByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) DeleteApplicationByNameAndSpaceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -6396,11 +7531,7 @@ func (fake *FakeActor) DeleteApplicationByNameAndSpaceReturnsOnCall(i int, resul func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Lock() ret, specificReturn := fake.deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall[len(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall)] - fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall, FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs{arg1, arg2, arg3}) stub := fake.DeleteBuildpackByNameAndStackAndLifecycleStub fakeReturns := fake.deleteBuildpackByNameAndStackAndLifecycleReturns fake.recordInvocation("DeleteBuildpackByNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3}) @@ -6430,7 +7561,15 @@ func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleArgsForCall(i in fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RLock() defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RUnlock() argsForCall := fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleArgs() []FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs { + fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RLock() + defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RUnlock() + args := make([]FakeActorDeleteBuildpackByNameAndStackAndLifecycleArgs, len(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall)) + copy(args, fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall) + return args } func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleReturns(result1 v7action.Warnings, result2 error) { @@ -6462,9 +7601,7 @@ func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleReturnsOnCall(i func (fake *FakeActor) DeleteDomain(arg1 resources.Domain) (v7action.Warnings, error) { fake.deleteDomainMutex.Lock() ret, specificReturn := fake.deleteDomainReturnsOnCall[len(fake.deleteDomainArgsForCall)] - fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, struct { - arg1 resources.Domain - }{arg1}) + fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, FakeActorDeleteDomainArgs{arg1}) stub := fake.DeleteDomainStub fakeReturns := fake.deleteDomainReturns fake.recordInvocation("DeleteDomain", []interface{}{arg1}) @@ -6494,7 +7631,15 @@ func (fake *FakeActor) DeleteDomainArgsForCall(i int) resources.Domain { fake.deleteDomainMutex.RLock() defer fake.deleteDomainMutex.RUnlock() argsForCall := fake.deleteDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteDomainArgs() []FakeActorDeleteDomainArgs { + fake.deleteDomainMutex.RLock() + defer fake.deleteDomainMutex.RUnlock() + args := make([]FakeActorDeleteDomainArgs, len(fake.deleteDomainArgsForCall)) + copy(args, fake.deleteDomainArgsForCall) + return args } func (fake *FakeActor) DeleteDomainReturns(result1 v7action.Warnings, result2 error) { @@ -6526,12 +7671,7 @@ func (fake *FakeActor) DeleteDomainReturnsOnCall(i int, result1 v7action.Warning func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex(arg1 string, arg2 string, arg3 string, arg4 int) (v7action.Warnings, error) { fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Lock() ret, specificReturn := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[len(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall)] - fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall, FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs{arg1, arg2, arg3, arg4}) stub := fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub fakeReturns := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns fake.recordInvocation("DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4}) @@ -6561,7 +7701,15 @@ func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexAr fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RLock() defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock() argsForCall := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs() []FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs { + fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RLock() + defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock() + args := make([]FakeActorDeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgs, len(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall)) + copy(args, fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall) + return args } func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns(result1 v7action.Warnings, result2 error) { @@ -6593,9 +7741,7 @@ func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexRe func (fake *FakeActor) DeleteIsolationSegmentByName(arg1 string) (v7action.Warnings, error) { fake.deleteIsolationSegmentByNameMutex.Lock() ret, specificReturn := fake.deleteIsolationSegmentByNameReturnsOnCall[len(fake.deleteIsolationSegmentByNameArgsForCall)] - fake.deleteIsolationSegmentByNameArgsForCall = append(fake.deleteIsolationSegmentByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteIsolationSegmentByNameArgsForCall = append(fake.deleteIsolationSegmentByNameArgsForCall, FakeActorDeleteIsolationSegmentByNameArgs{arg1}) stub := fake.DeleteIsolationSegmentByNameStub fakeReturns := fake.deleteIsolationSegmentByNameReturns fake.recordInvocation("DeleteIsolationSegmentByName", []interface{}{arg1}) @@ -6625,7 +7771,15 @@ func (fake *FakeActor) DeleteIsolationSegmentByNameArgsForCall(i int) string { fake.deleteIsolationSegmentByNameMutex.RLock() defer fake.deleteIsolationSegmentByNameMutex.RUnlock() argsForCall := fake.deleteIsolationSegmentByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteIsolationSegmentByNameArgs() []FakeActorDeleteIsolationSegmentByNameArgs { + fake.deleteIsolationSegmentByNameMutex.RLock() + defer fake.deleteIsolationSegmentByNameMutex.RUnlock() + args := make([]FakeActorDeleteIsolationSegmentByNameArgs, len(fake.deleteIsolationSegmentByNameArgsForCall)) + copy(args, fake.deleteIsolationSegmentByNameArgsForCall) + return args } func (fake *FakeActor) DeleteIsolationSegmentByNameReturns(result1 v7action.Warnings, result2 error) { @@ -6657,10 +7811,7 @@ func (fake *FakeActor) DeleteIsolationSegmentByNameReturnsOnCall(i int, result1 func (fake *FakeActor) DeleteIsolationSegmentOrganizationByName(arg1 string, arg2 string) (v7action.Warnings, error) { fake.deleteIsolationSegmentOrganizationByNameMutex.Lock() ret, specificReturn := fake.deleteIsolationSegmentOrganizationByNameReturnsOnCall[len(fake.deleteIsolationSegmentOrganizationByNameArgsForCall)] - fake.deleteIsolationSegmentOrganizationByNameArgsForCall = append(fake.deleteIsolationSegmentOrganizationByNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteIsolationSegmentOrganizationByNameArgsForCall = append(fake.deleteIsolationSegmentOrganizationByNameArgsForCall, FakeActorDeleteIsolationSegmentOrganizationByNameArgs{arg1, arg2}) stub := fake.DeleteIsolationSegmentOrganizationByNameStub fakeReturns := fake.deleteIsolationSegmentOrganizationByNameReturns fake.recordInvocation("DeleteIsolationSegmentOrganizationByName", []interface{}{arg1, arg2}) @@ -6690,7 +7841,15 @@ func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameArgsForCall(i int fake.deleteIsolationSegmentOrganizationByNameMutex.RLock() defer fake.deleteIsolationSegmentOrganizationByNameMutex.RUnlock() argsForCall := fake.deleteIsolationSegmentOrganizationByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameArgs() []FakeActorDeleteIsolationSegmentOrganizationByNameArgs { + fake.deleteIsolationSegmentOrganizationByNameMutex.RLock() + defer fake.deleteIsolationSegmentOrganizationByNameMutex.RUnlock() + args := make([]FakeActorDeleteIsolationSegmentOrganizationByNameArgs, len(fake.deleteIsolationSegmentOrganizationByNameArgsForCall)) + copy(args, fake.deleteIsolationSegmentOrganizationByNameArgsForCall) + return args } func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameReturns(result1 v7action.Warnings, result2 error) { @@ -6722,13 +7881,7 @@ func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameReturnsOnCall(i i func (fake *FakeActor) DeleteOrgRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) { fake.deleteOrgRoleMutex.Lock() ret, specificReturn := fake.deleteOrgRoleReturnsOnCall[len(fake.deleteOrgRoleArgsForCall)] - fake.deleteOrgRoleArgsForCall = append(fake.deleteOrgRoleArgsForCall, struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + fake.deleteOrgRoleArgsForCall = append(fake.deleteOrgRoleArgsForCall, FakeActorDeleteOrgRoleArgs{arg1, arg2, arg3, arg4, arg5}) stub := fake.DeleteOrgRoleStub fakeReturns := fake.deleteOrgRoleReturns fake.recordInvocation("DeleteOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5}) @@ -6758,7 +7911,15 @@ func (fake *FakeActor) DeleteOrgRoleArgsForCall(i int) (constanta.RoleType, stri fake.deleteOrgRoleMutex.RLock() defer fake.deleteOrgRoleMutex.RUnlock() argsForCall := fake.deleteOrgRoleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) DeleteOrgRoleArgs() []FakeActorDeleteOrgRoleArgs { + fake.deleteOrgRoleMutex.RLock() + defer fake.deleteOrgRoleMutex.RUnlock() + args := make([]FakeActorDeleteOrgRoleArgs, len(fake.deleteOrgRoleArgsForCall)) + copy(args, fake.deleteOrgRoleArgsForCall) + return args } func (fake *FakeActor) DeleteOrgRoleReturns(result1 v7action.Warnings, result2 error) { @@ -6790,9 +7951,7 @@ func (fake *FakeActor) DeleteOrgRoleReturnsOnCall(i int, result1 v7action.Warnin func (fake *FakeActor) DeleteOrganization(arg1 string) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteOrganizationMutex.Lock() ret, specificReturn := fake.deleteOrganizationReturnsOnCall[len(fake.deleteOrganizationArgsForCall)] - fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, FakeActorDeleteOrganizationArgs{arg1}) stub := fake.DeleteOrganizationStub fakeReturns := fake.deleteOrganizationReturns fake.recordInvocation("DeleteOrganization", []interface{}{arg1}) @@ -6822,7 +7981,15 @@ func (fake *FakeActor) DeleteOrganizationArgsForCall(i int) string { fake.deleteOrganizationMutex.RLock() defer fake.deleteOrganizationMutex.RUnlock() argsForCall := fake.deleteOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteOrganizationArgs() []FakeActorDeleteOrganizationArgs { + fake.deleteOrganizationMutex.RLock() + defer fake.deleteOrganizationMutex.RUnlock() + args := make([]FakeActorDeleteOrganizationArgs, len(fake.deleteOrganizationArgsForCall)) + copy(args, fake.deleteOrganizationArgsForCall) + return args } func (fake *FakeActor) DeleteOrganizationReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -6857,9 +8024,7 @@ func (fake *FakeActor) DeleteOrganizationReturnsOnCall(i int, result1 chan v7act func (fake *FakeActor) DeleteOrganizationQuota(arg1 string) (v7action.Warnings, error) { fake.deleteOrganizationQuotaMutex.Lock() ret, specificReturn := fake.deleteOrganizationQuotaReturnsOnCall[len(fake.deleteOrganizationQuotaArgsForCall)] - fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, FakeActorDeleteOrganizationQuotaArgs{arg1}) stub := fake.DeleteOrganizationQuotaStub fakeReturns := fake.deleteOrganizationQuotaReturns fake.recordInvocation("DeleteOrganizationQuota", []interface{}{arg1}) @@ -6889,7 +8054,15 @@ func (fake *FakeActor) DeleteOrganizationQuotaArgsForCall(i int) string { fake.deleteOrganizationQuotaMutex.RLock() defer fake.deleteOrganizationQuotaMutex.RUnlock() argsForCall := fake.deleteOrganizationQuotaArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteOrganizationQuotaArgs() []FakeActorDeleteOrganizationQuotaArgs { + fake.deleteOrganizationQuotaMutex.RLock() + defer fake.deleteOrganizationQuotaMutex.RUnlock() + args := make([]FakeActorDeleteOrganizationQuotaArgs, len(fake.deleteOrganizationQuotaArgsForCall)) + copy(args, fake.deleteOrganizationQuotaArgsForCall) + return args } func (fake *FakeActor) DeleteOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -6921,9 +8094,7 @@ func (fake *FakeActor) DeleteOrganizationQuotaReturnsOnCall(i int, result1 v7act func (fake *FakeActor) DeleteOrphanedRoutes(arg1 string) (v7action.Warnings, error) { fake.deleteOrphanedRoutesMutex.Lock() ret, specificReturn := fake.deleteOrphanedRoutesReturnsOnCall[len(fake.deleteOrphanedRoutesArgsForCall)] - fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, FakeActorDeleteOrphanedRoutesArgs{arg1}) stub := fake.DeleteOrphanedRoutesStub fakeReturns := fake.deleteOrphanedRoutesReturns fake.recordInvocation("DeleteOrphanedRoutes", []interface{}{arg1}) @@ -6953,7 +8124,15 @@ func (fake *FakeActor) DeleteOrphanedRoutesArgsForCall(i int) string { fake.deleteOrphanedRoutesMutex.RLock() defer fake.deleteOrphanedRoutesMutex.RUnlock() argsForCall := fake.deleteOrphanedRoutesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteOrphanedRoutesArgs() []FakeActorDeleteOrphanedRoutesArgs { + fake.deleteOrphanedRoutesMutex.RLock() + defer fake.deleteOrphanedRoutesMutex.RUnlock() + args := make([]FakeActorDeleteOrphanedRoutesArgs, len(fake.deleteOrphanedRoutesArgsForCall)) + copy(args, fake.deleteOrphanedRoutesArgsForCall) + return args } func (fake *FakeActor) DeleteOrphanedRoutesReturns(result1 v7action.Warnings, result2 error) { @@ -6985,12 +8164,7 @@ func (fake *FakeActor) DeleteOrphanedRoutesReturnsOnCall(i int, result1 v7action func (fake *FakeActor) DeleteRoute(arg1 string, arg2 string, arg3 string, arg4 int) (v7action.Warnings, error) { fake.deleteRouteMutex.Lock() ret, specificReturn := fake.deleteRouteReturnsOnCall[len(fake.deleteRouteArgsForCall)] - fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, FakeActorDeleteRouteArgs{arg1, arg2, arg3, arg4}) stub := fake.DeleteRouteStub fakeReturns := fake.deleteRouteReturns fake.recordInvocation("DeleteRoute", []interface{}{arg1, arg2, arg3, arg4}) @@ -7020,7 +8194,15 @@ func (fake *FakeActor) DeleteRouteArgsForCall(i int) (string, string, string, in fake.deleteRouteMutex.RLock() defer fake.deleteRouteMutex.RUnlock() argsForCall := fake.deleteRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) DeleteRouteArgs() []FakeActorDeleteRouteArgs { + fake.deleteRouteMutex.RLock() + defer fake.deleteRouteMutex.RUnlock() + args := make([]FakeActorDeleteRouteArgs, len(fake.deleteRouteArgsForCall)) + copy(args, fake.deleteRouteArgsForCall) + return args } func (fake *FakeActor) DeleteRouteReturns(result1 v7action.Warnings, result2 error) { @@ -7052,9 +8234,7 @@ func (fake *FakeActor) DeleteRouteReturnsOnCall(i int, result1 v7action.Warnings func (fake *FakeActor) DeleteRouteBinding(arg1 v7action.DeleteRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteRouteBindingMutex.Lock() ret, specificReturn := fake.deleteRouteBindingReturnsOnCall[len(fake.deleteRouteBindingArgsForCall)] - fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, struct { - arg1 v7action.DeleteRouteBindingParams - }{arg1}) + fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, FakeActorDeleteRouteBindingArgs{arg1}) stub := fake.DeleteRouteBindingStub fakeReturns := fake.deleteRouteBindingReturns fake.recordInvocation("DeleteRouteBinding", []interface{}{arg1}) @@ -7084,7 +8264,15 @@ func (fake *FakeActor) DeleteRouteBindingArgsForCall(i int) v7action.DeleteRoute fake.deleteRouteBindingMutex.RLock() defer fake.deleteRouteBindingMutex.RUnlock() argsForCall := fake.deleteRouteBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteRouteBindingArgs() []FakeActorDeleteRouteBindingArgs { + fake.deleteRouteBindingMutex.RLock() + defer fake.deleteRouteBindingMutex.RUnlock() + args := make([]FakeActorDeleteRouteBindingArgs, len(fake.deleteRouteBindingArgsForCall)) + copy(args, fake.deleteRouteBindingArgsForCall) + return args } func (fake *FakeActor) DeleteRouteBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -7119,12 +8307,7 @@ func (fake *FakeActor) DeleteRouteBindingReturnsOnCall(i int, result1 chan v7act func (fake *FakeActor) DeleteRoutePolicyBySource(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { fake.deleteRoutePolicyBySourceMutex.Lock() ret, specificReturn := fake.deleteRoutePolicyBySourceReturnsOnCall[len(fake.deleteRoutePolicyBySourceArgsForCall)] - fake.deleteRoutePolicyBySourceArgsForCall = append(fake.deleteRoutePolicyBySourceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.deleteRoutePolicyBySourceArgsForCall = append(fake.deleteRoutePolicyBySourceArgsForCall, FakeActorDeleteRoutePolicyBySourceArgs{arg1, arg2, arg3, arg4}) stub := fake.DeleteRoutePolicyBySourceStub fakeReturns := fake.deleteRoutePolicyBySourceReturns fake.recordInvocation("DeleteRoutePolicyBySource", []interface{}{arg1, arg2, arg3, arg4}) @@ -7154,7 +8337,15 @@ func (fake *FakeActor) DeleteRoutePolicyBySourceArgsForCall(i int) (string, stri fake.deleteRoutePolicyBySourceMutex.RLock() defer fake.deleteRoutePolicyBySourceMutex.RUnlock() argsForCall := fake.deleteRoutePolicyBySourceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) DeleteRoutePolicyBySourceArgs() []FakeActorDeleteRoutePolicyBySourceArgs { + fake.deleteRoutePolicyBySourceMutex.RLock() + defer fake.deleteRoutePolicyBySourceMutex.RUnlock() + args := make([]FakeActorDeleteRoutePolicyBySourceArgs, len(fake.deleteRoutePolicyBySourceArgsForCall)) + copy(args, fake.deleteRoutePolicyBySourceArgsForCall) + return args } func (fake *FakeActor) DeleteRoutePolicyBySourceReturns(result1 v7action.Warnings, result2 error) { @@ -7186,9 +8377,7 @@ func (fake *FakeActor) DeleteRoutePolicyBySourceReturnsOnCall(i int, result1 v7a func (fake *FakeActor) DeleteSecurityGroup(arg1 string) (v7action.Warnings, error) { fake.deleteSecurityGroupMutex.Lock() ret, specificReturn := fake.deleteSecurityGroupReturnsOnCall[len(fake.deleteSecurityGroupArgsForCall)] - fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, FakeActorDeleteSecurityGroupArgs{arg1}) stub := fake.DeleteSecurityGroupStub fakeReturns := fake.deleteSecurityGroupReturns fake.recordInvocation("DeleteSecurityGroup", []interface{}{arg1}) @@ -7218,7 +8407,15 @@ func (fake *FakeActor) DeleteSecurityGroupArgsForCall(i int) string { fake.deleteSecurityGroupMutex.RLock() defer fake.deleteSecurityGroupMutex.RUnlock() argsForCall := fake.deleteSecurityGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteSecurityGroupArgs() []FakeActorDeleteSecurityGroupArgs { + fake.deleteSecurityGroupMutex.RLock() + defer fake.deleteSecurityGroupMutex.RUnlock() + args := make([]FakeActorDeleteSecurityGroupArgs, len(fake.deleteSecurityGroupArgsForCall)) + copy(args, fake.deleteSecurityGroupArgsForCall) + return args } func (fake *FakeActor) DeleteSecurityGroupReturns(result1 v7action.Warnings, result2 error) { @@ -7247,12 +8444,80 @@ func (fake *FakeActor) DeleteSecurityGroupReturnsOnCall(i int, result1 v7action. }{result1, result2} } +func (fake *FakeActor) DeleteServiceAccountByNameAndSpace(arg1 string, arg2 string) (v7action.Warnings, error) { + fake.deleteServiceAccountByNameAndSpaceMutex.Lock() + ret, specificReturn := fake.deleteServiceAccountByNameAndSpaceReturnsOnCall[len(fake.deleteServiceAccountByNameAndSpaceArgsForCall)] + fake.deleteServiceAccountByNameAndSpaceArgsForCall = append(fake.deleteServiceAccountByNameAndSpaceArgsForCall, FakeActorDeleteServiceAccountByNameAndSpaceArgs{arg1, arg2}) + stub := fake.DeleteServiceAccountByNameAndSpaceStub + fakeReturns := fake.deleteServiceAccountByNameAndSpaceReturns + fake.recordInvocation("DeleteServiceAccountByNameAndSpace", []interface{}{arg1, arg2}) + fake.deleteServiceAccountByNameAndSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceCallCount() int { + fake.deleteServiceAccountByNameAndSpaceMutex.RLock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.RUnlock() + return len(fake.deleteServiceAccountByNameAndSpaceArgsForCall) +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceCalls(stub func(string, string) (v7action.Warnings, error)) { + fake.deleteServiceAccountByNameAndSpaceMutex.Lock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.Unlock() + fake.DeleteServiceAccountByNameAndSpaceStub = stub +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceArgsForCall(i int) (string, string) { + fake.deleteServiceAccountByNameAndSpaceMutex.RLock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.RUnlock() + argsForCall := fake.deleteServiceAccountByNameAndSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceArgs() []FakeActorDeleteServiceAccountByNameAndSpaceArgs { + fake.deleteServiceAccountByNameAndSpaceMutex.RLock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorDeleteServiceAccountByNameAndSpaceArgs, len(fake.deleteServiceAccountByNameAndSpaceArgsForCall)) + copy(args, fake.deleteServiceAccountByNameAndSpaceArgsForCall) + return args +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { + fake.deleteServiceAccountByNameAndSpaceMutex.Lock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.Unlock() + fake.DeleteServiceAccountByNameAndSpaceStub = nil + fake.deleteServiceAccountByNameAndSpaceReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) DeleteServiceAccountByNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.deleteServiceAccountByNameAndSpaceMutex.Lock() + defer fake.deleteServiceAccountByNameAndSpaceMutex.Unlock() + fake.DeleteServiceAccountByNameAndSpaceStub = nil + if fake.deleteServiceAccountByNameAndSpaceReturnsOnCall == nil { + fake.deleteServiceAccountByNameAndSpaceReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.deleteServiceAccountByNameAndSpaceReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + func (fake *FakeActor) DeleteServiceAppBinding(arg1 v7action.DeleteServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteServiceAppBindingMutex.Lock() ret, specificReturn := fake.deleteServiceAppBindingReturnsOnCall[len(fake.deleteServiceAppBindingArgsForCall)] - fake.deleteServiceAppBindingArgsForCall = append(fake.deleteServiceAppBindingArgsForCall, struct { - arg1 v7action.DeleteServiceAppBindingParams - }{arg1}) + fake.deleteServiceAppBindingArgsForCall = append(fake.deleteServiceAppBindingArgsForCall, FakeActorDeleteServiceAppBindingArgs{arg1}) stub := fake.DeleteServiceAppBindingStub fakeReturns := fake.deleteServiceAppBindingReturns fake.recordInvocation("DeleteServiceAppBinding", []interface{}{arg1}) @@ -7282,7 +8547,15 @@ func (fake *FakeActor) DeleteServiceAppBindingArgsForCall(i int) v7action.Delete fake.deleteServiceAppBindingMutex.RLock() defer fake.deleteServiceAppBindingMutex.RUnlock() argsForCall := fake.deleteServiceAppBindingArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteServiceAppBindingArgs() []FakeActorDeleteServiceAppBindingArgs { + fake.deleteServiceAppBindingMutex.RLock() + defer fake.deleteServiceAppBindingMutex.RUnlock() + args := make([]FakeActorDeleteServiceAppBindingArgs, len(fake.deleteServiceAppBindingArgsForCall)) + copy(args, fake.deleteServiceAppBindingArgsForCall) + return args } func (fake *FakeActor) DeleteServiceAppBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -7317,9 +8590,7 @@ func (fake *FakeActor) DeleteServiceAppBindingReturnsOnCall(i int, result1 chan func (fake *FakeActor) DeleteServiceBroker(arg1 string) (v7action.Warnings, error) { fake.deleteServiceBrokerMutex.Lock() ret, specificReturn := fake.deleteServiceBrokerReturnsOnCall[len(fake.deleteServiceBrokerArgsForCall)] - fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, FakeActorDeleteServiceBrokerArgs{arg1}) stub := fake.DeleteServiceBrokerStub fakeReturns := fake.deleteServiceBrokerReturns fake.recordInvocation("DeleteServiceBroker", []interface{}{arg1}) @@ -7349,7 +8620,15 @@ func (fake *FakeActor) DeleteServiceBrokerArgsForCall(i int) string { fake.deleteServiceBrokerMutex.RLock() defer fake.deleteServiceBrokerMutex.RUnlock() argsForCall := fake.deleteServiceBrokerArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteServiceBrokerArgs() []FakeActorDeleteServiceBrokerArgs { + fake.deleteServiceBrokerMutex.RLock() + defer fake.deleteServiceBrokerMutex.RUnlock() + args := make([]FakeActorDeleteServiceBrokerArgs, len(fake.deleteServiceBrokerArgsForCall)) + copy(args, fake.deleteServiceBrokerArgsForCall) + return args } func (fake *FakeActor) DeleteServiceBrokerReturns(result1 v7action.Warnings, result2 error) { @@ -7381,10 +8660,7 @@ func (fake *FakeActor) DeleteServiceBrokerReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) DeleteServiceInstance(arg1 string, arg2 string) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteServiceInstanceMutex.Lock() ret, specificReturn := fake.deleteServiceInstanceReturnsOnCall[len(fake.deleteServiceInstanceArgsForCall)] - fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, FakeActorDeleteServiceInstanceArgs{arg1, arg2}) stub := fake.DeleteServiceInstanceStub fakeReturns := fake.deleteServiceInstanceReturns fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2}) @@ -7414,7 +8690,15 @@ func (fake *FakeActor) DeleteServiceInstanceArgsForCall(i int) (string, string) fake.deleteServiceInstanceMutex.RLock() defer fake.deleteServiceInstanceMutex.RUnlock() argsForCall := fake.deleteServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DeleteServiceInstanceArgs() []FakeActorDeleteServiceInstanceArgs { + fake.deleteServiceInstanceMutex.RLock() + defer fake.deleteServiceInstanceMutex.RUnlock() + args := make([]FakeActorDeleteServiceInstanceArgs, len(fake.deleteServiceInstanceArgsForCall)) + copy(args, fake.deleteServiceInstanceArgsForCall) + return args } func (fake *FakeActor) DeleteServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -7449,11 +8733,7 @@ func (fake *FakeActor) DeleteServiceInstanceReturnsOnCall(i int, result1 chan v7 func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteServiceKeyByServiceInstanceAndNameMutex.Lock() ret, specificReturn := fake.deleteServiceKeyByServiceInstanceAndNameReturnsOnCall[len(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall)] - fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall, FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs{arg1, arg2, arg3}) stub := fake.DeleteServiceKeyByServiceInstanceAndNameStub fakeReturns := fake.deleteServiceKeyByServiceInstanceAndNameReturns fake.recordInvocation("DeleteServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3}) @@ -7483,7 +8763,15 @@ func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameArgsForCall(i int fake.deleteServiceKeyByServiceInstanceAndNameMutex.RLock() defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.RUnlock() argsForCall := fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameArgs() []FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs { + fake.deleteServiceKeyByServiceInstanceAndNameMutex.RLock() + defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.RUnlock() + args := make([]FakeActorDeleteServiceKeyByServiceInstanceAndNameArgs, len(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall)) + copy(args, fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall) + return args } func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -7518,10 +8806,7 @@ func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameReturnsOnCall(i i func (fake *FakeActor) DeleteSpaceByNameAndOrganizationName(arg1 string, arg2 string) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.deleteSpaceByNameAndOrganizationNameMutex.Lock() ret, specificReturn := fake.deleteSpaceByNameAndOrganizationNameReturnsOnCall[len(fake.deleteSpaceByNameAndOrganizationNameArgsForCall)] - fake.deleteSpaceByNameAndOrganizationNameArgsForCall = append(fake.deleteSpaceByNameAndOrganizationNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteSpaceByNameAndOrganizationNameArgsForCall = append(fake.deleteSpaceByNameAndOrganizationNameArgsForCall, FakeActorDeleteSpaceByNameAndOrganizationNameArgs{arg1, arg2}) stub := fake.DeleteSpaceByNameAndOrganizationNameStub fakeReturns := fake.deleteSpaceByNameAndOrganizationNameReturns fake.recordInvocation("DeleteSpaceByNameAndOrganizationName", []interface{}{arg1, arg2}) @@ -7551,7 +8836,15 @@ func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameArgsForCall(i int) (s fake.deleteSpaceByNameAndOrganizationNameMutex.RLock() defer fake.deleteSpaceByNameAndOrganizationNameMutex.RUnlock() argsForCall := fake.deleteSpaceByNameAndOrganizationNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameArgs() []FakeActorDeleteSpaceByNameAndOrganizationNameArgs { + fake.deleteSpaceByNameAndOrganizationNameMutex.RLock() + defer fake.deleteSpaceByNameAndOrganizationNameMutex.RUnlock() + args := make([]FakeActorDeleteSpaceByNameAndOrganizationNameArgs, len(fake.deleteSpaceByNameAndOrganizationNameArgsForCall)) + copy(args, fake.deleteSpaceByNameAndOrganizationNameArgsForCall) + return args } func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -7586,10 +8879,7 @@ func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameReturnsOnCall(i int, func (fake *FakeActor) DeleteSpaceQuotaByName(arg1 string, arg2 string) (v7action.Warnings, error) { fake.deleteSpaceQuotaByNameMutex.Lock() ret, specificReturn := fake.deleteSpaceQuotaByNameReturnsOnCall[len(fake.deleteSpaceQuotaByNameArgsForCall)] - fake.deleteSpaceQuotaByNameArgsForCall = append(fake.deleteSpaceQuotaByNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.deleteSpaceQuotaByNameArgsForCall = append(fake.deleteSpaceQuotaByNameArgsForCall, FakeActorDeleteSpaceQuotaByNameArgs{arg1, arg2}) stub := fake.DeleteSpaceQuotaByNameStub fakeReturns := fake.deleteSpaceQuotaByNameReturns fake.recordInvocation("DeleteSpaceQuotaByName", []interface{}{arg1, arg2}) @@ -7619,7 +8909,15 @@ func (fake *FakeActor) DeleteSpaceQuotaByNameArgsForCall(i int) (string, string) fake.deleteSpaceQuotaByNameMutex.RLock() defer fake.deleteSpaceQuotaByNameMutex.RUnlock() argsForCall := fake.deleteSpaceQuotaByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DeleteSpaceQuotaByNameArgs() []FakeActorDeleteSpaceQuotaByNameArgs { + fake.deleteSpaceQuotaByNameMutex.RLock() + defer fake.deleteSpaceQuotaByNameMutex.RUnlock() + args := make([]FakeActorDeleteSpaceQuotaByNameArgs, len(fake.deleteSpaceQuotaByNameArgsForCall)) + copy(args, fake.deleteSpaceQuotaByNameArgsForCall) + return args } func (fake *FakeActor) DeleteSpaceQuotaByNameReturns(result1 v7action.Warnings, result2 error) { @@ -7651,13 +8949,7 @@ func (fake *FakeActor) DeleteSpaceQuotaByNameReturnsOnCall(i int, result1 v7acti func (fake *FakeActor) DeleteSpaceRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) { fake.deleteSpaceRoleMutex.Lock() ret, specificReturn := fake.deleteSpaceRoleReturnsOnCall[len(fake.deleteSpaceRoleArgsForCall)] - fake.deleteSpaceRoleArgsForCall = append(fake.deleteSpaceRoleArgsForCall, struct { - arg1 constanta.RoleType - arg2 string - arg3 string - arg4 string - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + fake.deleteSpaceRoleArgsForCall = append(fake.deleteSpaceRoleArgsForCall, FakeActorDeleteSpaceRoleArgs{arg1, arg2, arg3, arg4, arg5}) stub := fake.DeleteSpaceRoleStub fakeReturns := fake.deleteSpaceRoleReturns fake.recordInvocation("DeleteSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5}) @@ -7687,7 +8979,15 @@ func (fake *FakeActor) DeleteSpaceRoleArgsForCall(i int) (constanta.RoleType, st fake.deleteSpaceRoleMutex.RLock() defer fake.deleteSpaceRoleMutex.RUnlock() argsForCall := fake.deleteSpaceRoleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) DeleteSpaceRoleArgs() []FakeActorDeleteSpaceRoleArgs { + fake.deleteSpaceRoleMutex.RLock() + defer fake.deleteSpaceRoleMutex.RUnlock() + args := make([]FakeActorDeleteSpaceRoleArgs, len(fake.deleteSpaceRoleArgsForCall)) + copy(args, fake.deleteSpaceRoleArgsForCall) + return args } func (fake *FakeActor) DeleteSpaceRoleReturns(result1 v7action.Warnings, result2 error) { @@ -7719,9 +9019,7 @@ func (fake *FakeActor) DeleteSpaceRoleReturnsOnCall(i int, result1 v7action.Warn func (fake *FakeActor) DeleteUser(arg1 string) (v7action.Warnings, error) { fake.deleteUserMutex.Lock() ret, specificReturn := fake.deleteUserReturnsOnCall[len(fake.deleteUserArgsForCall)] - fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, struct { - arg1 string - }{arg1}) + fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, FakeActorDeleteUserArgs{arg1}) stub := fake.DeleteUserStub fakeReturns := fake.deleteUserReturns fake.recordInvocation("DeleteUser", []interface{}{arg1}) @@ -7751,7 +9049,15 @@ func (fake *FakeActor) DeleteUserArgsForCall(i int) string { fake.deleteUserMutex.RLock() defer fake.deleteUserMutex.RUnlock() argsForCall := fake.deleteUserArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DeleteUserArgs() []FakeActorDeleteUserArgs { + fake.deleteUserMutex.RLock() + defer fake.deleteUserMutex.RUnlock() + args := make([]FakeActorDeleteUserArgs, len(fake.deleteUserArgsForCall)) + copy(args, fake.deleteUserArgsForCall) + return args } func (fake *FakeActor) DeleteUserReturns(result1 v7action.Warnings, result2 error) { @@ -7788,10 +9094,7 @@ func (fake *FakeActor) DiffSpaceManifest(arg1 string, arg2 []byte) (resources.Ma } fake.diffSpaceManifestMutex.Lock() ret, specificReturn := fake.diffSpaceManifestReturnsOnCall[len(fake.diffSpaceManifestArgsForCall)] - fake.diffSpaceManifestArgsForCall = append(fake.diffSpaceManifestArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.diffSpaceManifestArgsForCall = append(fake.diffSpaceManifestArgsForCall, FakeActorDiffSpaceManifestArgs{arg1, arg2Copy}) stub := fake.DiffSpaceManifestStub fakeReturns := fake.diffSpaceManifestReturns fake.recordInvocation("DiffSpaceManifest", []interface{}{arg1, arg2Copy}) @@ -7821,7 +9124,15 @@ func (fake *FakeActor) DiffSpaceManifestArgsForCall(i int) (string, []byte) { fake.diffSpaceManifestMutex.RLock() defer fake.diffSpaceManifestMutex.RUnlock() argsForCall := fake.diffSpaceManifestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DiffSpaceManifestArgs() []FakeActorDiffSpaceManifestArgs { + fake.diffSpaceManifestMutex.RLock() + defer fake.diffSpaceManifestMutex.RUnlock() + args := make([]FakeActorDiffSpaceManifestArgs, len(fake.diffSpaceManifestArgsForCall)) + copy(args, fake.diffSpaceManifestArgsForCall) + return args } func (fake *FakeActor) DiffSpaceManifestReturns(result1 resources.ManifestDiff, result2 v7action.Warnings, result3 error) { @@ -7856,9 +9167,7 @@ func (fake *FakeActor) DiffSpaceManifestReturnsOnCall(i int, result1 resources.M func (fake *FakeActor) DisableFeatureFlag(arg1 string) (v7action.Warnings, error) { fake.disableFeatureFlagMutex.Lock() ret, specificReturn := fake.disableFeatureFlagReturnsOnCall[len(fake.disableFeatureFlagArgsForCall)] - fake.disableFeatureFlagArgsForCall = append(fake.disableFeatureFlagArgsForCall, struct { - arg1 string - }{arg1}) + fake.disableFeatureFlagArgsForCall = append(fake.disableFeatureFlagArgsForCall, FakeActorDisableFeatureFlagArgs{arg1}) stub := fake.DisableFeatureFlagStub fakeReturns := fake.disableFeatureFlagReturns fake.recordInvocation("DisableFeatureFlag", []interface{}{arg1}) @@ -7888,7 +9197,15 @@ func (fake *FakeActor) DisableFeatureFlagArgsForCall(i int) string { fake.disableFeatureFlagMutex.RLock() defer fake.disableFeatureFlagMutex.RUnlock() argsForCall := fake.disableFeatureFlagArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) DisableFeatureFlagArgs() []FakeActorDisableFeatureFlagArgs { + fake.disableFeatureFlagMutex.RLock() + defer fake.disableFeatureFlagMutex.RUnlock() + args := make([]FakeActorDisableFeatureFlagArgs, len(fake.disableFeatureFlagArgsForCall)) + copy(args, fake.disableFeatureFlagArgsForCall) + return args } func (fake *FakeActor) DisableFeatureFlagReturns(result1 v7action.Warnings, result2 error) { @@ -7920,12 +9237,7 @@ func (fake *FakeActor) DisableFeatureFlagReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) DisableServiceAccess(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.SkippedPlans, v7action.Warnings, error) { fake.disableServiceAccessMutex.Lock() ret, specificReturn := fake.disableServiceAccessReturnsOnCall[len(fake.disableServiceAccessArgsForCall)] - fake.disableServiceAccessArgsForCall = append(fake.disableServiceAccessArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.disableServiceAccessArgsForCall = append(fake.disableServiceAccessArgsForCall, FakeActorDisableServiceAccessArgs{arg1, arg2, arg3, arg4}) stub := fake.DisableServiceAccessStub fakeReturns := fake.disableServiceAccessReturns fake.recordInvocation("DisableServiceAccess", []interface{}{arg1, arg2, arg3, arg4}) @@ -7955,7 +9267,15 @@ func (fake *FakeActor) DisableServiceAccessArgsForCall(i int) (string, string, s fake.disableServiceAccessMutex.RLock() defer fake.disableServiceAccessMutex.RUnlock() argsForCall := fake.disableServiceAccessArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) DisableServiceAccessArgs() []FakeActorDisableServiceAccessArgs { + fake.disableServiceAccessMutex.RLock() + defer fake.disableServiceAccessMutex.RUnlock() + args := make([]FakeActorDisableServiceAccessArgs, len(fake.disableServiceAccessArgsForCall)) + copy(args, fake.disableServiceAccessArgsForCall) + return args } func (fake *FakeActor) DisableServiceAccessReturns(result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) { @@ -7990,10 +9310,7 @@ func (fake *FakeActor) DisableServiceAccessReturnsOnCall(i int, result1 v7action func (fake *FakeActor) DownloadCurrentDropletByAppName(arg1 string, arg2 string) ([]byte, string, v7action.Warnings, error) { fake.downloadCurrentDropletByAppNameMutex.Lock() ret, specificReturn := fake.downloadCurrentDropletByAppNameReturnsOnCall[len(fake.downloadCurrentDropletByAppNameArgsForCall)] - fake.downloadCurrentDropletByAppNameArgsForCall = append(fake.downloadCurrentDropletByAppNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.downloadCurrentDropletByAppNameArgsForCall = append(fake.downloadCurrentDropletByAppNameArgsForCall, FakeActorDownloadCurrentDropletByAppNameArgs{arg1, arg2}) stub := fake.DownloadCurrentDropletByAppNameStub fakeReturns := fake.downloadCurrentDropletByAppNameReturns fake.recordInvocation("DownloadCurrentDropletByAppName", []interface{}{arg1, arg2}) @@ -8023,7 +9340,15 @@ func (fake *FakeActor) DownloadCurrentDropletByAppNameArgsForCall(i int) (string fake.downloadCurrentDropletByAppNameMutex.RLock() defer fake.downloadCurrentDropletByAppNameMutex.RUnlock() argsForCall := fake.downloadCurrentDropletByAppNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) DownloadCurrentDropletByAppNameArgs() []FakeActorDownloadCurrentDropletByAppNameArgs { + fake.downloadCurrentDropletByAppNameMutex.RLock() + defer fake.downloadCurrentDropletByAppNameMutex.RUnlock() + args := make([]FakeActorDownloadCurrentDropletByAppNameArgs, len(fake.downloadCurrentDropletByAppNameArgsForCall)) + copy(args, fake.downloadCurrentDropletByAppNameArgsForCall) + return args } func (fake *FakeActor) DownloadCurrentDropletByAppNameReturns(result1 []byte, result2 string, result3 v7action.Warnings, result4 error) { @@ -8061,11 +9386,7 @@ func (fake *FakeActor) DownloadCurrentDropletByAppNameReturnsOnCall(i int, resul func (fake *FakeActor) DownloadDropletByGUIDAndAppName(arg1 string, arg2 string, arg3 string) ([]byte, v7action.Warnings, error) { fake.downloadDropletByGUIDAndAppNameMutex.Lock() ret, specificReturn := fake.downloadDropletByGUIDAndAppNameReturnsOnCall[len(fake.downloadDropletByGUIDAndAppNameArgsForCall)] - fake.downloadDropletByGUIDAndAppNameArgsForCall = append(fake.downloadDropletByGUIDAndAppNameArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.downloadDropletByGUIDAndAppNameArgsForCall = append(fake.downloadDropletByGUIDAndAppNameArgsForCall, FakeActorDownloadDropletByGUIDAndAppNameArgs{arg1, arg2, arg3}) stub := fake.DownloadDropletByGUIDAndAppNameStub fakeReturns := fake.downloadDropletByGUIDAndAppNameReturns fake.recordInvocation("DownloadDropletByGUIDAndAppName", []interface{}{arg1, arg2, arg3}) @@ -8095,7 +9416,15 @@ func (fake *FakeActor) DownloadDropletByGUIDAndAppNameArgsForCall(i int) (string fake.downloadDropletByGUIDAndAppNameMutex.RLock() defer fake.downloadDropletByGUIDAndAppNameMutex.RUnlock() argsForCall := fake.downloadDropletByGUIDAndAppNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) DownloadDropletByGUIDAndAppNameArgs() []FakeActorDownloadDropletByGUIDAndAppNameArgs { + fake.downloadDropletByGUIDAndAppNameMutex.RLock() + defer fake.downloadDropletByGUIDAndAppNameMutex.RUnlock() + args := make([]FakeActorDownloadDropletByGUIDAndAppNameArgs, len(fake.downloadDropletByGUIDAndAppNameArgsForCall)) + copy(args, fake.downloadDropletByGUIDAndAppNameArgsForCall) + return args } func (fake *FakeActor) DownloadDropletByGUIDAndAppNameReturns(result1 []byte, result2 v7action.Warnings, result3 error) { @@ -8130,9 +9459,7 @@ func (fake *FakeActor) DownloadDropletByGUIDAndAppNameReturnsOnCall(i int, resul func (fake *FakeActor) EnableFeatureFlag(arg1 string) (v7action.Warnings, error) { fake.enableFeatureFlagMutex.Lock() ret, specificReturn := fake.enableFeatureFlagReturnsOnCall[len(fake.enableFeatureFlagArgsForCall)] - fake.enableFeatureFlagArgsForCall = append(fake.enableFeatureFlagArgsForCall, struct { - arg1 string - }{arg1}) + fake.enableFeatureFlagArgsForCall = append(fake.enableFeatureFlagArgsForCall, FakeActorEnableFeatureFlagArgs{arg1}) stub := fake.EnableFeatureFlagStub fakeReturns := fake.enableFeatureFlagReturns fake.recordInvocation("EnableFeatureFlag", []interface{}{arg1}) @@ -8162,7 +9489,15 @@ func (fake *FakeActor) EnableFeatureFlagArgsForCall(i int) string { fake.enableFeatureFlagMutex.RLock() defer fake.enableFeatureFlagMutex.RUnlock() argsForCall := fake.enableFeatureFlagArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) EnableFeatureFlagArgs() []FakeActorEnableFeatureFlagArgs { + fake.enableFeatureFlagMutex.RLock() + defer fake.enableFeatureFlagMutex.RUnlock() + args := make([]FakeActorEnableFeatureFlagArgs, len(fake.enableFeatureFlagArgsForCall)) + copy(args, fake.enableFeatureFlagArgsForCall) + return args } func (fake *FakeActor) EnableFeatureFlagReturns(result1 v7action.Warnings, result2 error) { @@ -8194,12 +9529,7 @@ func (fake *FakeActor) EnableFeatureFlagReturnsOnCall(i int, result1 v7action.Wa func (fake *FakeActor) EnableServiceAccess(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.SkippedPlans, v7action.Warnings, error) { fake.enableServiceAccessMutex.Lock() ret, specificReturn := fake.enableServiceAccessReturnsOnCall[len(fake.enableServiceAccessArgsForCall)] - fake.enableServiceAccessArgsForCall = append(fake.enableServiceAccessArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.enableServiceAccessArgsForCall = append(fake.enableServiceAccessArgsForCall, FakeActorEnableServiceAccessArgs{arg1, arg2, arg3, arg4}) stub := fake.EnableServiceAccessStub fakeReturns := fake.enableServiceAccessReturns fake.recordInvocation("EnableServiceAccess", []interface{}{arg1, arg2, arg3, arg4}) @@ -8229,7 +9559,15 @@ func (fake *FakeActor) EnableServiceAccessArgsForCall(i int) (string, string, st fake.enableServiceAccessMutex.RLock() defer fake.enableServiceAccessMutex.RUnlock() argsForCall := fake.enableServiceAccessArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) EnableServiceAccessArgs() []FakeActorEnableServiceAccessArgs { + fake.enableServiceAccessMutex.RLock() + defer fake.enableServiceAccessMutex.RUnlock() + args := make([]FakeActorEnableServiceAccessArgs, len(fake.enableServiceAccessArgsForCall)) + copy(args, fake.enableServiceAccessArgsForCall) + return args } func (fake *FakeActor) EnableServiceAccessReturns(result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) { @@ -8264,10 +9602,7 @@ func (fake *FakeActor) EnableServiceAccessReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByName(arg1 string, arg2 string) (v7action.Warnings, error) { fake.entitleIsolationSegmentToOrganizationByNameMutex.Lock() ret, specificReturn := fake.entitleIsolationSegmentToOrganizationByNameReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall)] - fake.entitleIsolationSegmentToOrganizationByNameArgsForCall = append(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.entitleIsolationSegmentToOrganizationByNameArgsForCall = append(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall, FakeActorEntitleIsolationSegmentToOrganizationByNameArgs{arg1, arg2}) stub := fake.EntitleIsolationSegmentToOrganizationByNameStub fakeReturns := fake.entitleIsolationSegmentToOrganizationByNameReturns fake.recordInvocation("EntitleIsolationSegmentToOrganizationByName", []interface{}{arg1, arg2}) @@ -8297,7 +9632,15 @@ func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameArgsForCall(i fake.entitleIsolationSegmentToOrganizationByNameMutex.RLock() defer fake.entitleIsolationSegmentToOrganizationByNameMutex.RUnlock() argsForCall := fake.entitleIsolationSegmentToOrganizationByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameArgs() []FakeActorEntitleIsolationSegmentToOrganizationByNameArgs { + fake.entitleIsolationSegmentToOrganizationByNameMutex.RLock() + defer fake.entitleIsolationSegmentToOrganizationByNameMutex.RUnlock() + args := make([]FakeActorEntitleIsolationSegmentToOrganizationByNameArgs, len(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall)) + copy(args, fake.entitleIsolationSegmentToOrganizationByNameArgsForCall) + return args } func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameReturns(result1 v7action.Warnings, result2 error) { @@ -8329,10 +9672,7 @@ func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameReturnsOnCall( func (fake *FakeActor) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, v7action.Warnings, error) { fake.getAppFeatureMutex.Lock() ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)] - fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, FakeActorGetAppFeatureArgs{arg1, arg2}) stub := fake.GetAppFeatureStub fakeReturns := fake.getAppFeatureReturns fake.recordInvocation("GetAppFeature", []interface{}{arg1, arg2}) @@ -8362,7 +9702,15 @@ func (fake *FakeActor) GetAppFeatureArgsForCall(i int) (string, string) { fake.getAppFeatureMutex.RLock() defer fake.getAppFeatureMutex.RUnlock() argsForCall := fake.getAppFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetAppFeatureArgs() []FakeActorGetAppFeatureArgs { + fake.getAppFeatureMutex.RLock() + defer fake.getAppFeatureMutex.RUnlock() + args := make([]FakeActorGetAppFeatureArgs, len(fake.getAppFeatureArgsForCall)) + copy(args, fake.getAppFeatureArgsForCall) + return args } func (fake *FakeActor) GetAppFeatureReturns(result1 resources.ApplicationFeature, result2 v7action.Warnings, result3 error) { @@ -8397,11 +9745,7 @@ func (fake *FakeActor) GetAppFeatureReturnsOnCall(i int, result1 resources.Appli func (fake *FakeActor) GetAppSummariesForSpace(arg1 string, arg2 string, arg3 bool) ([]v7action.ApplicationSummary, v7action.Warnings, error) { fake.getAppSummariesForSpaceMutex.Lock() ret, specificReturn := fake.getAppSummariesForSpaceReturnsOnCall[len(fake.getAppSummariesForSpaceArgsForCall)] - fake.getAppSummariesForSpaceArgsForCall = append(fake.getAppSummariesForSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - }{arg1, arg2, arg3}) + fake.getAppSummariesForSpaceArgsForCall = append(fake.getAppSummariesForSpaceArgsForCall, FakeActorGetAppSummariesForSpaceArgs{arg1, arg2, arg3}) stub := fake.GetAppSummariesForSpaceStub fakeReturns := fake.getAppSummariesForSpaceReturns fake.recordInvocation("GetAppSummariesForSpace", []interface{}{arg1, arg2, arg3}) @@ -8431,7 +9775,15 @@ func (fake *FakeActor) GetAppSummariesForSpaceArgsForCall(i int) (string, string fake.getAppSummariesForSpaceMutex.RLock() defer fake.getAppSummariesForSpaceMutex.RUnlock() argsForCall := fake.getAppSummariesForSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetAppSummariesForSpaceArgs() []FakeActorGetAppSummariesForSpaceArgs { + fake.getAppSummariesForSpaceMutex.RLock() + defer fake.getAppSummariesForSpaceMutex.RUnlock() + args := make([]FakeActorGetAppSummariesForSpaceArgs, len(fake.getAppSummariesForSpaceArgsForCall)) + copy(args, fake.getAppSummariesForSpaceArgsForCall) + return args } func (fake *FakeActor) GetAppSummariesForSpaceReturns(result1 []v7action.ApplicationSummary, result2 v7action.Warnings, result3 error) { @@ -8466,10 +9818,7 @@ func (fake *FakeActor) GetAppSummariesForSpaceReturnsOnCall(i int, result1 []v7a func (fake *FakeActor) GetApplicationByNameAndSpace(arg1 string, arg2 string) (resources.Application, v7action.Warnings, error) { fake.getApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getApplicationByNameAndSpaceReturnsOnCall[len(fake.getApplicationByNameAndSpaceArgsForCall)] - fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, FakeActorGetApplicationByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetApplicationByNameAndSpaceStub fakeReturns := fake.getApplicationByNameAndSpaceReturns fake.recordInvocation("GetApplicationByNameAndSpace", []interface{}{arg1, arg2}) @@ -8499,7 +9848,15 @@ func (fake *FakeActor) GetApplicationByNameAndSpaceArgsForCall(i int) (string, s fake.getApplicationByNameAndSpaceMutex.RLock() defer fake.getApplicationByNameAndSpaceMutex.RUnlock() argsForCall := fake.getApplicationByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationByNameAndSpaceArgs() []FakeActorGetApplicationByNameAndSpaceArgs { + fake.getApplicationByNameAndSpaceMutex.RLock() + defer fake.getApplicationByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetApplicationByNameAndSpaceArgs, len(fake.getApplicationByNameAndSpaceArgsForCall)) + copy(args, fake.getApplicationByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetApplicationByNameAndSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) { @@ -8534,10 +9891,7 @@ func (fake *FakeActor) GetApplicationByNameAndSpaceReturnsOnCall(i int, result1 func (fake *FakeActor) GetApplicationDroplets(arg1 string, arg2 string) ([]resources.Droplet, v7action.Warnings, error) { fake.getApplicationDropletsMutex.Lock() ret, specificReturn := fake.getApplicationDropletsReturnsOnCall[len(fake.getApplicationDropletsArgsForCall)] - fake.getApplicationDropletsArgsForCall = append(fake.getApplicationDropletsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationDropletsArgsForCall = append(fake.getApplicationDropletsArgsForCall, FakeActorGetApplicationDropletsArgs{arg1, arg2}) stub := fake.GetApplicationDropletsStub fakeReturns := fake.getApplicationDropletsReturns fake.recordInvocation("GetApplicationDroplets", []interface{}{arg1, arg2}) @@ -8567,7 +9921,15 @@ func (fake *FakeActor) GetApplicationDropletsArgsForCall(i int) (string, string) fake.getApplicationDropletsMutex.RLock() defer fake.getApplicationDropletsMutex.RUnlock() argsForCall := fake.getApplicationDropletsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationDropletsArgs() []FakeActorGetApplicationDropletsArgs { + fake.getApplicationDropletsMutex.RLock() + defer fake.getApplicationDropletsMutex.RUnlock() + args := make([]FakeActorGetApplicationDropletsArgs, len(fake.getApplicationDropletsArgsForCall)) + copy(args, fake.getApplicationDropletsArgsForCall) + return args } func (fake *FakeActor) GetApplicationDropletsReturns(result1 []resources.Droplet, result2 v7action.Warnings, result3 error) { @@ -8602,10 +9964,7 @@ func (fake *FakeActor) GetApplicationDropletsReturnsOnCall(i int, result1 []reso func (fake *FakeActor) GetApplicationLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getApplicationLabelsMutex.Lock() ret, specificReturn := fake.getApplicationLabelsReturnsOnCall[len(fake.getApplicationLabelsArgsForCall)] - fake.getApplicationLabelsArgsForCall = append(fake.getApplicationLabelsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationLabelsArgsForCall = append(fake.getApplicationLabelsArgsForCall, FakeActorGetApplicationLabelsArgs{arg1, arg2}) stub := fake.GetApplicationLabelsStub fakeReturns := fake.getApplicationLabelsReturns fake.recordInvocation("GetApplicationLabels", []interface{}{arg1, arg2}) @@ -8635,7 +9994,15 @@ func (fake *FakeActor) GetApplicationLabelsArgsForCall(i int) (string, string) { fake.getApplicationLabelsMutex.RLock() defer fake.getApplicationLabelsMutex.RUnlock() argsForCall := fake.getApplicationLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationLabelsArgs() []FakeActorGetApplicationLabelsArgs { + fake.getApplicationLabelsMutex.RLock() + defer fake.getApplicationLabelsMutex.RUnlock() + args := make([]FakeActorGetApplicationLabelsArgs, len(fake.getApplicationLabelsArgsForCall)) + copy(args, fake.getApplicationLabelsArgsForCall) + return args } func (fake *FakeActor) GetApplicationLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -8670,9 +10037,7 @@ func (fake *FakeActor) GetApplicationLabelsReturnsOnCall(i int, result1 map[stri func (fake *FakeActor) GetApplicationMapForRoute(arg1 resources.Route) (map[string]resources.Application, v7action.Warnings, error) { fake.getApplicationMapForRouteMutex.Lock() ret, specificReturn := fake.getApplicationMapForRouteReturnsOnCall[len(fake.getApplicationMapForRouteArgsForCall)] - fake.getApplicationMapForRouteArgsForCall = append(fake.getApplicationMapForRouteArgsForCall, struct { - arg1 resources.Route - }{arg1}) + fake.getApplicationMapForRouteArgsForCall = append(fake.getApplicationMapForRouteArgsForCall, FakeActorGetApplicationMapForRouteArgs{arg1}) stub := fake.GetApplicationMapForRouteStub fakeReturns := fake.getApplicationMapForRouteReturns fake.recordInvocation("GetApplicationMapForRoute", []interface{}{arg1}) @@ -8702,7 +10067,15 @@ func (fake *FakeActor) GetApplicationMapForRouteArgsForCall(i int) resources.Rou fake.getApplicationMapForRouteMutex.RLock() defer fake.getApplicationMapForRouteMutex.RUnlock() argsForCall := fake.getApplicationMapForRouteArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetApplicationMapForRouteArgs() []FakeActorGetApplicationMapForRouteArgs { + fake.getApplicationMapForRouteMutex.RLock() + defer fake.getApplicationMapForRouteMutex.RUnlock() + args := make([]FakeActorGetApplicationMapForRouteArgs, len(fake.getApplicationMapForRouteArgsForCall)) + copy(args, fake.getApplicationMapForRouteArgsForCall) + return args } func (fake *FakeActor) GetApplicationMapForRouteReturns(result1 map[string]resources.Application, result2 v7action.Warnings, result3 error) { @@ -8737,10 +10110,7 @@ func (fake *FakeActor) GetApplicationMapForRouteReturnsOnCall(i int, result1 map func (fake *FakeActor) GetApplicationPackages(arg1 string, arg2 string) ([]resources.Package, v7action.Warnings, error) { fake.getApplicationPackagesMutex.Lock() ret, specificReturn := fake.getApplicationPackagesReturnsOnCall[len(fake.getApplicationPackagesArgsForCall)] - fake.getApplicationPackagesArgsForCall = append(fake.getApplicationPackagesArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationPackagesArgsForCall = append(fake.getApplicationPackagesArgsForCall, FakeActorGetApplicationPackagesArgs{arg1, arg2}) stub := fake.GetApplicationPackagesStub fakeReturns := fake.getApplicationPackagesReturns fake.recordInvocation("GetApplicationPackages", []interface{}{arg1, arg2}) @@ -8770,7 +10140,15 @@ func (fake *FakeActor) GetApplicationPackagesArgsForCall(i int) (string, string) fake.getApplicationPackagesMutex.RLock() defer fake.getApplicationPackagesMutex.RUnlock() argsForCall := fake.getApplicationPackagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationPackagesArgs() []FakeActorGetApplicationPackagesArgs { + fake.getApplicationPackagesMutex.RLock() + defer fake.getApplicationPackagesMutex.RUnlock() + args := make([]FakeActorGetApplicationPackagesArgs, len(fake.getApplicationPackagesArgsForCall)) + copy(args, fake.getApplicationPackagesArgsForCall) + return args } func (fake *FakeActor) GetApplicationPackagesReturns(result1 []resources.Package, result2 v7action.Warnings, result3 error) { @@ -8805,10 +10183,7 @@ func (fake *FakeActor) GetApplicationPackagesReturnsOnCall(i int, result1 []reso func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpace(arg1 string, arg2 string) ([]v7action.ProcessHealthCheck, v7action.Warnings, error) { fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall[len(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall)] - fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall, FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetApplicationProcessHealthChecksByNameAndSpaceStub fakeReturns := fake.getApplicationProcessHealthChecksByNameAndSpaceReturns fake.recordInvocation("GetApplicationProcessHealthChecksByNameAndSpace", []interface{}{arg1, arg2}) @@ -8838,7 +10213,15 @@ func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceArgsForCal fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RLock() defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RUnlock() argsForCall := fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceArgs() []FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs { + fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RLock() + defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetApplicationProcessHealthChecksByNameAndSpaceArgs, len(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall)) + copy(args, fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceReturns(result1 []v7action.ProcessHealthCheck, result2 v7action.Warnings, result3 error) { @@ -8873,10 +10256,7 @@ func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceReturnsOnC func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpace(arg1 string, arg2 string) ([]v7action.ProcessReadinessHealthCheck, v7action.Warnings, error) { fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall[len(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall)] - fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall, FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub fakeReturns := fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns fake.recordInvocation("GetApplicationProcessReadinessHealthChecksByNameAndSpace", []interface{}{arg1, arg2}) @@ -8906,7 +10286,15 @@ func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceA fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RLock() defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RUnlock() argsForCall := fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs() []FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs { + fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RLock() + defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetApplicationProcessReadinessHealthChecksByNameAndSpaceArgs, len(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall)) + copy(args, fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceReturns(result1 []v7action.ProcessReadinessHealthCheck, result2 v7action.Warnings, result3 error) { @@ -8941,9 +10329,7 @@ func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceR func (fake *FakeActor) GetApplicationRevisionsDeployed(arg1 string) ([]resources.Revision, v7action.Warnings, error) { fake.getApplicationRevisionsDeployedMutex.Lock() ret, specificReturn := fake.getApplicationRevisionsDeployedReturnsOnCall[len(fake.getApplicationRevisionsDeployedArgsForCall)] - fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, FakeActorGetApplicationRevisionsDeployedArgs{arg1}) stub := fake.GetApplicationRevisionsDeployedStub fakeReturns := fake.getApplicationRevisionsDeployedReturns fake.recordInvocation("GetApplicationRevisionsDeployed", []interface{}{arg1}) @@ -8973,7 +10359,15 @@ func (fake *FakeActor) GetApplicationRevisionsDeployedArgsForCall(i int) string fake.getApplicationRevisionsDeployedMutex.RLock() defer fake.getApplicationRevisionsDeployedMutex.RUnlock() argsForCall := fake.getApplicationRevisionsDeployedArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetApplicationRevisionsDeployedArgs() []FakeActorGetApplicationRevisionsDeployedArgs { + fake.getApplicationRevisionsDeployedMutex.RLock() + defer fake.getApplicationRevisionsDeployedMutex.RUnlock() + args := make([]FakeActorGetApplicationRevisionsDeployedArgs, len(fake.getApplicationRevisionsDeployedArgsForCall)) + copy(args, fake.getApplicationRevisionsDeployedArgsForCall) + return args } func (fake *FakeActor) GetApplicationRevisionsDeployedReturns(result1 []resources.Revision, result2 v7action.Warnings, result3 error) { @@ -9008,9 +10402,7 @@ func (fake *FakeActor) GetApplicationRevisionsDeployedReturnsOnCall(i int, resul func (fake *FakeActor) GetApplicationRoutes(arg1 string) ([]resources.Route, v7action.Warnings, error) { fake.getApplicationRoutesMutex.Lock() ret, specificReturn := fake.getApplicationRoutesReturnsOnCall[len(fake.getApplicationRoutesArgsForCall)] - fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, FakeActorGetApplicationRoutesArgs{arg1}) stub := fake.GetApplicationRoutesStub fakeReturns := fake.getApplicationRoutesReturns fake.recordInvocation("GetApplicationRoutes", []interface{}{arg1}) @@ -9040,7 +10432,15 @@ func (fake *FakeActor) GetApplicationRoutesArgsForCall(i int) string { fake.getApplicationRoutesMutex.RLock() defer fake.getApplicationRoutesMutex.RUnlock() argsForCall := fake.getApplicationRoutesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetApplicationRoutesArgs() []FakeActorGetApplicationRoutesArgs { + fake.getApplicationRoutesMutex.RLock() + defer fake.getApplicationRoutesMutex.RUnlock() + args := make([]FakeActorGetApplicationRoutesArgs, len(fake.getApplicationRoutesArgsForCall)) + copy(args, fake.getApplicationRoutesArgsForCall) + return args } func (fake *FakeActor) GetApplicationRoutesReturns(result1 []resources.Route, result2 v7action.Warnings, result3 error) { @@ -9075,10 +10475,7 @@ func (fake *FakeActor) GetApplicationRoutesReturnsOnCall(i int, result1 []resour func (fake *FakeActor) GetApplicationTasks(arg1 string, arg2 v7action.SortOrder) ([]resources.Task, v7action.Warnings, error) { fake.getApplicationTasksMutex.Lock() ret, specificReturn := fake.getApplicationTasksReturnsOnCall[len(fake.getApplicationTasksArgsForCall)] - fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, struct { - arg1 string - arg2 v7action.SortOrder - }{arg1, arg2}) + fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, FakeActorGetApplicationTasksArgs{arg1, arg2}) stub := fake.GetApplicationTasksStub fakeReturns := fake.getApplicationTasksReturns fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2}) @@ -9108,7 +10505,15 @@ func (fake *FakeActor) GetApplicationTasksArgsForCall(i int) (string, v7action.S fake.getApplicationTasksMutex.RLock() defer fake.getApplicationTasksMutex.RUnlock() argsForCall := fake.getApplicationTasksArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationTasksArgs() []FakeActorGetApplicationTasksArgs { + fake.getApplicationTasksMutex.RLock() + defer fake.getApplicationTasksMutex.RUnlock() + args := make([]FakeActorGetApplicationTasksArgs, len(fake.getApplicationTasksArgsForCall)) + copy(args, fake.getApplicationTasksArgsForCall) + return args } func (fake *FakeActor) GetApplicationTasksReturns(result1 []resources.Task, result2 v7action.Warnings, result3 error) { @@ -9148,9 +10553,7 @@ func (fake *FakeActor) GetApplicationsByGUIDs(arg1 []string) ([]resources.Applic } fake.getApplicationsByGUIDsMutex.Lock() ret, specificReturn := fake.getApplicationsByGUIDsReturnsOnCall[len(fake.getApplicationsByGUIDsArgsForCall)] - fake.getApplicationsByGUIDsArgsForCall = append(fake.getApplicationsByGUIDsArgsForCall, struct { - arg1 []string - }{arg1Copy}) + fake.getApplicationsByGUIDsArgsForCall = append(fake.getApplicationsByGUIDsArgsForCall, FakeActorGetApplicationsByGUIDsArgs{arg1Copy}) stub := fake.GetApplicationsByGUIDsStub fakeReturns := fake.getApplicationsByGUIDsReturns fake.recordInvocation("GetApplicationsByGUIDs", []interface{}{arg1Copy}) @@ -9180,7 +10583,15 @@ func (fake *FakeActor) GetApplicationsByGUIDsArgsForCall(i int) []string { fake.getApplicationsByGUIDsMutex.RLock() defer fake.getApplicationsByGUIDsMutex.RUnlock() argsForCall := fake.getApplicationsByGUIDsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetApplicationsByGUIDsArgs() []FakeActorGetApplicationsByGUIDsArgs { + fake.getApplicationsByGUIDsMutex.RLock() + defer fake.getApplicationsByGUIDsMutex.RUnlock() + args := make([]FakeActorGetApplicationsByGUIDsArgs, len(fake.getApplicationsByGUIDsArgsForCall)) + copy(args, fake.getApplicationsByGUIDsArgsForCall) + return args } func (fake *FakeActor) GetApplicationsByGUIDsReturns(result1 []resources.Application, result2 v7action.Warnings, result3 error) { @@ -9220,10 +10631,7 @@ func (fake *FakeActor) GetApplicationsByNamesAndSpace(arg1 []string, arg2 string } fake.getApplicationsByNamesAndSpaceMutex.Lock() ret, specificReturn := fake.getApplicationsByNamesAndSpaceReturnsOnCall[len(fake.getApplicationsByNamesAndSpaceArgsForCall)] - fake.getApplicationsByNamesAndSpaceArgsForCall = append(fake.getApplicationsByNamesAndSpaceArgsForCall, struct { - arg1 []string - arg2 string - }{arg1Copy, arg2}) + fake.getApplicationsByNamesAndSpaceArgsForCall = append(fake.getApplicationsByNamesAndSpaceArgsForCall, FakeActorGetApplicationsByNamesAndSpaceArgs{arg1Copy, arg2}) stub := fake.GetApplicationsByNamesAndSpaceStub fakeReturns := fake.getApplicationsByNamesAndSpaceReturns fake.recordInvocation("GetApplicationsByNamesAndSpace", []interface{}{arg1Copy, arg2}) @@ -9253,7 +10661,15 @@ func (fake *FakeActor) GetApplicationsByNamesAndSpaceArgsForCall(i int) ([]strin fake.getApplicationsByNamesAndSpaceMutex.RLock() defer fake.getApplicationsByNamesAndSpaceMutex.RUnlock() argsForCall := fake.getApplicationsByNamesAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetApplicationsByNamesAndSpaceArgs() []FakeActorGetApplicationsByNamesAndSpaceArgs { + fake.getApplicationsByNamesAndSpaceMutex.RLock() + defer fake.getApplicationsByNamesAndSpaceMutex.RUnlock() + args := make([]FakeActorGetApplicationsByNamesAndSpaceArgs, len(fake.getApplicationsByNamesAndSpaceArgsForCall)) + copy(args, fake.getApplicationsByNamesAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetApplicationsByNamesAndSpaceReturns(result1 []resources.Application, result2 v7action.Warnings, result3 error) { @@ -9288,11 +10704,7 @@ func (fake *FakeActor) GetApplicationsByNamesAndSpaceReturnsOnCall(i int, result func (fake *FakeActor) GetBuildpackLabels(arg1 string, arg2 string, arg3 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getBuildpackLabelsMutex.Lock() ret, specificReturn := fake.getBuildpackLabelsReturnsOnCall[len(fake.getBuildpackLabelsArgsForCall)] - fake.getBuildpackLabelsArgsForCall = append(fake.getBuildpackLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getBuildpackLabelsArgsForCall = append(fake.getBuildpackLabelsArgsForCall, FakeActorGetBuildpackLabelsArgs{arg1, arg2, arg3}) stub := fake.GetBuildpackLabelsStub fakeReturns := fake.getBuildpackLabelsReturns fake.recordInvocation("GetBuildpackLabels", []interface{}{arg1, arg2, arg3}) @@ -9322,7 +10734,15 @@ func (fake *FakeActor) GetBuildpackLabelsArgsForCall(i int) (string, string, str fake.getBuildpackLabelsMutex.RLock() defer fake.getBuildpackLabelsMutex.RUnlock() argsForCall := fake.getBuildpackLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetBuildpackLabelsArgs() []FakeActorGetBuildpackLabelsArgs { + fake.getBuildpackLabelsMutex.RLock() + defer fake.getBuildpackLabelsMutex.RUnlock() + args := make([]FakeActorGetBuildpackLabelsArgs, len(fake.getBuildpackLabelsArgsForCall)) + copy(args, fake.getBuildpackLabelsArgsForCall) + return args } func (fake *FakeActor) GetBuildpackLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -9357,10 +10777,7 @@ func (fake *FakeActor) GetBuildpackLabelsReturnsOnCall(i int, result1 map[string func (fake *FakeActor) GetBuildpacks(arg1 string, arg2 string) ([]resources.Buildpack, v7action.Warnings, error) { fake.getBuildpacksMutex.Lock() ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)] - fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, FakeActorGetBuildpacksArgs{arg1, arg2}) stub := fake.GetBuildpacksStub fakeReturns := fake.getBuildpacksReturns fake.recordInvocation("GetBuildpacks", []interface{}{arg1, arg2}) @@ -9390,7 +10807,15 @@ func (fake *FakeActor) GetBuildpacksArgsForCall(i int) (string, string) { fake.getBuildpacksMutex.RLock() defer fake.getBuildpacksMutex.RUnlock() argsForCall := fake.getBuildpacksArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetBuildpacksArgs() []FakeActorGetBuildpacksArgs { + fake.getBuildpacksMutex.RLock() + defer fake.getBuildpacksMutex.RUnlock() + args := make([]FakeActorGetBuildpacksArgs, len(fake.getBuildpacksArgsForCall)) + copy(args, fake.getBuildpacksArgsForCall) + return args } func (fake *FakeActor) GetBuildpacksReturns(result1 []resources.Buildpack, result2 v7action.Warnings, result3 error) { @@ -9425,8 +10850,7 @@ func (fake *FakeActor) GetBuildpacksReturnsOnCall(i int, result1 []resources.Bui func (fake *FakeActor) GetCurrentUser() (configv3.User, error) { fake.getCurrentUserMutex.Lock() ret, specificReturn := fake.getCurrentUserReturnsOnCall[len(fake.getCurrentUserArgsForCall)] - fake.getCurrentUserArgsForCall = append(fake.getCurrentUserArgsForCall, struct { - }{}) + fake.getCurrentUserArgsForCall = append(fake.getCurrentUserArgsForCall, struct{}{}) stub := fake.GetCurrentUserStub fakeReturns := fake.getCurrentUserReturns fake.recordInvocation("GetCurrentUser", []interface{}{}) @@ -9481,9 +10905,7 @@ func (fake *FakeActor) GetCurrentUserReturnsOnCall(i int, result1 configv3.User, func (fake *FakeActor) GetDefaultDomain(arg1 string) (resources.Domain, v7action.Warnings, error) { fake.getDefaultDomainMutex.Lock() ret, specificReturn := fake.getDefaultDomainReturnsOnCall[len(fake.getDefaultDomainArgsForCall)] - fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, FakeActorGetDefaultDomainArgs{arg1}) stub := fake.GetDefaultDomainStub fakeReturns := fake.getDefaultDomainReturns fake.recordInvocation("GetDefaultDomain", []interface{}{arg1}) @@ -9513,7 +10935,15 @@ func (fake *FakeActor) GetDefaultDomainArgsForCall(i int) string { fake.getDefaultDomainMutex.RLock() defer fake.getDefaultDomainMutex.RUnlock() argsForCall := fake.getDefaultDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetDefaultDomainArgs() []FakeActorGetDefaultDomainArgs { + fake.getDefaultDomainMutex.RLock() + defer fake.getDefaultDomainMutex.RUnlock() + args := make([]FakeActorGetDefaultDomainArgs, len(fake.getDefaultDomainArgsForCall)) + copy(args, fake.getDefaultDomainArgsForCall) + return args } func (fake *FakeActor) GetDefaultDomainReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) { @@ -9548,11 +10978,7 @@ func (fake *FakeActor) GetDefaultDomainReturnsOnCall(i int, result1 resources.Do func (fake *FakeActor) GetDetailedAppSummary(arg1 string, arg2 string, arg3 bool) (v7action.DetailedApplicationSummary, v7action.Warnings, error) { fake.getDetailedAppSummaryMutex.Lock() ret, specificReturn := fake.getDetailedAppSummaryReturnsOnCall[len(fake.getDetailedAppSummaryArgsForCall)] - fake.getDetailedAppSummaryArgsForCall = append(fake.getDetailedAppSummaryArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - }{arg1, arg2, arg3}) + fake.getDetailedAppSummaryArgsForCall = append(fake.getDetailedAppSummaryArgsForCall, FakeActorGetDetailedAppSummaryArgs{arg1, arg2, arg3}) stub := fake.GetDetailedAppSummaryStub fakeReturns := fake.getDetailedAppSummaryReturns fake.recordInvocation("GetDetailedAppSummary", []interface{}{arg1, arg2, arg3}) @@ -9582,7 +11008,15 @@ func (fake *FakeActor) GetDetailedAppSummaryArgsForCall(i int) (string, string, fake.getDetailedAppSummaryMutex.RLock() defer fake.getDetailedAppSummaryMutex.RUnlock() argsForCall := fake.getDetailedAppSummaryArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetDetailedAppSummaryArgs() []FakeActorGetDetailedAppSummaryArgs { + fake.getDetailedAppSummaryMutex.RLock() + defer fake.getDetailedAppSummaryMutex.RUnlock() + args := make([]FakeActorGetDetailedAppSummaryArgs, len(fake.getDetailedAppSummaryArgsForCall)) + copy(args, fake.getDetailedAppSummaryArgsForCall) + return args } func (fake *FakeActor) GetDetailedAppSummaryReturns(result1 v7action.DetailedApplicationSummary, result2 v7action.Warnings, result3 error) { @@ -9617,9 +11051,7 @@ func (fake *FakeActor) GetDetailedAppSummaryReturnsOnCall(i int, result1 v7actio func (fake *FakeActor) GetDomain(arg1 string) (resources.Domain, v7action.Warnings, error) { fake.getDomainMutex.Lock() ret, specificReturn := fake.getDomainReturnsOnCall[len(fake.getDomainArgsForCall)] - fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, FakeActorGetDomainArgs{arg1}) stub := fake.GetDomainStub fakeReturns := fake.getDomainReturns fake.recordInvocation("GetDomain", []interface{}{arg1}) @@ -9649,7 +11081,15 @@ func (fake *FakeActor) GetDomainArgsForCall(i int) string { fake.getDomainMutex.RLock() defer fake.getDomainMutex.RUnlock() argsForCall := fake.getDomainArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetDomainArgs() []FakeActorGetDomainArgs { + fake.getDomainMutex.RLock() + defer fake.getDomainMutex.RUnlock() + args := make([]FakeActorGetDomainArgs, len(fake.getDomainArgsForCall)) + copy(args, fake.getDomainArgsForCall) + return args } func (fake *FakeActor) GetDomainReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) { @@ -9684,9 +11124,7 @@ func (fake *FakeActor) GetDomainReturnsOnCall(i int, result1 resources.Domain, r func (fake *FakeActor) GetDomainByName(arg1 string) (resources.Domain, v7action.Warnings, error) { fake.getDomainByNameMutex.Lock() ret, specificReturn := fake.getDomainByNameReturnsOnCall[len(fake.getDomainByNameArgsForCall)] - fake.getDomainByNameArgsForCall = append(fake.getDomainByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDomainByNameArgsForCall = append(fake.getDomainByNameArgsForCall, FakeActorGetDomainByNameArgs{arg1}) stub := fake.GetDomainByNameStub fakeReturns := fake.getDomainByNameReturns fake.recordInvocation("GetDomainByName", []interface{}{arg1}) @@ -9716,7 +11154,15 @@ func (fake *FakeActor) GetDomainByNameArgsForCall(i int) string { fake.getDomainByNameMutex.RLock() defer fake.getDomainByNameMutex.RUnlock() argsForCall := fake.getDomainByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetDomainByNameArgs() []FakeActorGetDomainByNameArgs { + fake.getDomainByNameMutex.RLock() + defer fake.getDomainByNameMutex.RUnlock() + args := make([]FakeActorGetDomainByNameArgs, len(fake.getDomainByNameArgsForCall)) + copy(args, fake.getDomainByNameArgsForCall) + return args } func (fake *FakeActor) GetDomainByNameReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) { @@ -9751,9 +11197,7 @@ func (fake *FakeActor) GetDomainByNameReturnsOnCall(i int, result1 resources.Dom func (fake *FakeActor) GetDomainLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getDomainLabelsMutex.Lock() ret, specificReturn := fake.getDomainLabelsReturnsOnCall[len(fake.getDomainLabelsArgsForCall)] - fake.getDomainLabelsArgsForCall = append(fake.getDomainLabelsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getDomainLabelsArgsForCall = append(fake.getDomainLabelsArgsForCall, FakeActorGetDomainLabelsArgs{arg1}) stub := fake.GetDomainLabelsStub fakeReturns := fake.getDomainLabelsReturns fake.recordInvocation("GetDomainLabels", []interface{}{arg1}) @@ -9783,7 +11227,15 @@ func (fake *FakeActor) GetDomainLabelsArgsForCall(i int) string { fake.getDomainLabelsMutex.RLock() defer fake.getDomainLabelsMutex.RUnlock() argsForCall := fake.getDomainLabelsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetDomainLabelsArgs() []FakeActorGetDomainLabelsArgs { + fake.getDomainLabelsMutex.RLock() + defer fake.getDomainLabelsMutex.RUnlock() + args := make([]FakeActorGetDomainLabelsArgs, len(fake.getDomainLabelsArgsForCall)) + copy(args, fake.getDomainLabelsArgsForCall) + return args } func (fake *FakeActor) GetDomainLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -9818,10 +11270,7 @@ func (fake *FakeActor) GetDomainLabelsReturnsOnCall(i int, result1 map[string]ty func (fake *FakeActor) GetEffectiveIsolationSegmentBySpace(arg1 string, arg2 string) (resources.IsolationSegment, v7action.Warnings, error) { fake.getEffectiveIsolationSegmentBySpaceMutex.Lock() ret, specificReturn := fake.getEffectiveIsolationSegmentBySpaceReturnsOnCall[len(fake.getEffectiveIsolationSegmentBySpaceArgsForCall)] - fake.getEffectiveIsolationSegmentBySpaceArgsForCall = append(fake.getEffectiveIsolationSegmentBySpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getEffectiveIsolationSegmentBySpaceArgsForCall = append(fake.getEffectiveIsolationSegmentBySpaceArgsForCall, FakeActorGetEffectiveIsolationSegmentBySpaceArgs{arg1, arg2}) stub := fake.GetEffectiveIsolationSegmentBySpaceStub fakeReturns := fake.getEffectiveIsolationSegmentBySpaceReturns fake.recordInvocation("GetEffectiveIsolationSegmentBySpace", []interface{}{arg1, arg2}) @@ -9851,7 +11300,15 @@ func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceArgsForCall(i int) (st fake.getEffectiveIsolationSegmentBySpaceMutex.RLock() defer fake.getEffectiveIsolationSegmentBySpaceMutex.RUnlock() argsForCall := fake.getEffectiveIsolationSegmentBySpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceArgs() []FakeActorGetEffectiveIsolationSegmentBySpaceArgs { + fake.getEffectiveIsolationSegmentBySpaceMutex.RLock() + defer fake.getEffectiveIsolationSegmentBySpaceMutex.RUnlock() + args := make([]FakeActorGetEffectiveIsolationSegmentBySpaceArgs, len(fake.getEffectiveIsolationSegmentBySpaceArgsForCall)) + copy(args, fake.getEffectiveIsolationSegmentBySpaceArgsForCall) + return args } func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceReturns(result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) { @@ -9886,9 +11343,7 @@ func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceReturnsOnCall(i int, r func (fake *FakeActor) GetEnvironmentVariableGroup(arg1 constanta.EnvironmentVariableGroupName) (v7action.EnvironmentVariableGroup, v7action.Warnings, error) { fake.getEnvironmentVariableGroupMutex.Lock() ret, specificReturn := fake.getEnvironmentVariableGroupReturnsOnCall[len(fake.getEnvironmentVariableGroupArgsForCall)] - fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, struct { - arg1 constanta.EnvironmentVariableGroupName - }{arg1}) + fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, FakeActorGetEnvironmentVariableGroupArgs{arg1}) stub := fake.GetEnvironmentVariableGroupStub fakeReturns := fake.getEnvironmentVariableGroupReturns fake.recordInvocation("GetEnvironmentVariableGroup", []interface{}{arg1}) @@ -9918,7 +11373,15 @@ func (fake *FakeActor) GetEnvironmentVariableGroupArgsForCall(i int) constanta.E fake.getEnvironmentVariableGroupMutex.RLock() defer fake.getEnvironmentVariableGroupMutex.RUnlock() argsForCall := fake.getEnvironmentVariableGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetEnvironmentVariableGroupArgs() []FakeActorGetEnvironmentVariableGroupArgs { + fake.getEnvironmentVariableGroupMutex.RLock() + defer fake.getEnvironmentVariableGroupMutex.RUnlock() + args := make([]FakeActorGetEnvironmentVariableGroupArgs, len(fake.getEnvironmentVariableGroupArgsForCall)) + copy(args, fake.getEnvironmentVariableGroupArgsForCall) + return args } func (fake *FakeActor) GetEnvironmentVariableGroupReturns(result1 v7action.EnvironmentVariableGroup, result2 v7action.Warnings, result3 error) { @@ -9953,9 +11416,7 @@ func (fake *FakeActor) GetEnvironmentVariableGroupReturnsOnCall(i int, result1 v func (fake *FakeActor) GetEnvironmentVariableGroupByRevision(arg1 resources.Revision) (v7action.EnvironmentVariableGroup, bool, v7action.Warnings, error) { fake.getEnvironmentVariableGroupByRevisionMutex.Lock() ret, specificReturn := fake.getEnvironmentVariableGroupByRevisionReturnsOnCall[len(fake.getEnvironmentVariableGroupByRevisionArgsForCall)] - fake.getEnvironmentVariableGroupByRevisionArgsForCall = append(fake.getEnvironmentVariableGroupByRevisionArgsForCall, struct { - arg1 resources.Revision - }{arg1}) + fake.getEnvironmentVariableGroupByRevisionArgsForCall = append(fake.getEnvironmentVariableGroupByRevisionArgsForCall, FakeActorGetEnvironmentVariableGroupByRevisionArgs{arg1}) stub := fake.GetEnvironmentVariableGroupByRevisionStub fakeReturns := fake.getEnvironmentVariableGroupByRevisionReturns fake.recordInvocation("GetEnvironmentVariableGroupByRevision", []interface{}{arg1}) @@ -9985,7 +11446,15 @@ func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionArgsForCall(i int) r fake.getEnvironmentVariableGroupByRevisionMutex.RLock() defer fake.getEnvironmentVariableGroupByRevisionMutex.RUnlock() argsForCall := fake.getEnvironmentVariableGroupByRevisionArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionArgs() []FakeActorGetEnvironmentVariableGroupByRevisionArgs { + fake.getEnvironmentVariableGroupByRevisionMutex.RLock() + defer fake.getEnvironmentVariableGroupByRevisionMutex.RUnlock() + args := make([]FakeActorGetEnvironmentVariableGroupByRevisionArgs, len(fake.getEnvironmentVariableGroupByRevisionArgsForCall)) + copy(args, fake.getEnvironmentVariableGroupByRevisionArgsForCall) + return args } func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionReturns(result1 v7action.EnvironmentVariableGroup, result2 bool, result3 v7action.Warnings, result4 error) { @@ -10023,10 +11492,7 @@ func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionReturnsOnCall(i int, func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpace(arg1 string, arg2 string) (v7action.EnvironmentVariableGroups, v7action.Warnings, error) { fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall[len(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall)] - fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall = append(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall = append(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall, FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs{arg1, arg2}) stub := fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub fakeReturns := fake.getEnvironmentVariablesByApplicationNameAndSpaceReturns fake.recordInvocation("GetEnvironmentVariablesByApplicationNameAndSpace", []interface{}{arg1, arg2}) @@ -10056,7 +11522,15 @@ func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceArgsForCa fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RLock() defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceArgs() []FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs { + fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RLock() + defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetEnvironmentVariablesByApplicationNameAndSpaceArgs, len(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceReturns(result1 v7action.EnvironmentVariableGroups, result2 v7action.Warnings, result3 error) { @@ -10091,9 +11565,7 @@ func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceReturnsOn func (fake *FakeActor) GetFeatureFlagByName(arg1 string) (resources.FeatureFlag, v7action.Warnings, error) { fake.getFeatureFlagByNameMutex.Lock() ret, specificReturn := fake.getFeatureFlagByNameReturnsOnCall[len(fake.getFeatureFlagByNameArgsForCall)] - fake.getFeatureFlagByNameArgsForCall = append(fake.getFeatureFlagByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getFeatureFlagByNameArgsForCall = append(fake.getFeatureFlagByNameArgsForCall, FakeActorGetFeatureFlagByNameArgs{arg1}) stub := fake.GetFeatureFlagByNameStub fakeReturns := fake.getFeatureFlagByNameReturns fake.recordInvocation("GetFeatureFlagByName", []interface{}{arg1}) @@ -10123,7 +11595,15 @@ func (fake *FakeActor) GetFeatureFlagByNameArgsForCall(i int) string { fake.getFeatureFlagByNameMutex.RLock() defer fake.getFeatureFlagByNameMutex.RUnlock() argsForCall := fake.getFeatureFlagByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetFeatureFlagByNameArgs() []FakeActorGetFeatureFlagByNameArgs { + fake.getFeatureFlagByNameMutex.RLock() + defer fake.getFeatureFlagByNameMutex.RUnlock() + args := make([]FakeActorGetFeatureFlagByNameArgs, len(fake.getFeatureFlagByNameArgsForCall)) + copy(args, fake.getFeatureFlagByNameArgsForCall) + return args } func (fake *FakeActor) GetFeatureFlagByNameReturns(result1 resources.FeatureFlag, result2 v7action.Warnings, result3 error) { @@ -10158,8 +11638,7 @@ func (fake *FakeActor) GetFeatureFlagByNameReturnsOnCall(i int, result1 resource func (fake *FakeActor) GetFeatureFlags() ([]resources.FeatureFlag, v7action.Warnings, error) { fake.getFeatureFlagsMutex.Lock() ret, specificReturn := fake.getFeatureFlagsReturnsOnCall[len(fake.getFeatureFlagsArgsForCall)] - fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct { - }{}) + fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct{}{}) stub := fake.GetFeatureFlagsStub fakeReturns := fake.getFeatureFlagsReturns fake.recordInvocation("GetFeatureFlags", []interface{}{}) @@ -10217,8 +11696,7 @@ func (fake *FakeActor) GetFeatureFlagsReturnsOnCall(i int, result1 []resources.F func (fake *FakeActor) GetGlobalRunningSecurityGroups() ([]resources.SecurityGroup, v7action.Warnings, error) { fake.getGlobalRunningSecurityGroupsMutex.Lock() ret, specificReturn := fake.getGlobalRunningSecurityGroupsReturnsOnCall[len(fake.getGlobalRunningSecurityGroupsArgsForCall)] - fake.getGlobalRunningSecurityGroupsArgsForCall = append(fake.getGlobalRunningSecurityGroupsArgsForCall, struct { - }{}) + fake.getGlobalRunningSecurityGroupsArgsForCall = append(fake.getGlobalRunningSecurityGroupsArgsForCall, struct{}{}) stub := fake.GetGlobalRunningSecurityGroupsStub fakeReturns := fake.getGlobalRunningSecurityGroupsReturns fake.recordInvocation("GetGlobalRunningSecurityGroups", []interface{}{}) @@ -10276,8 +11754,7 @@ func (fake *FakeActor) GetGlobalRunningSecurityGroupsReturnsOnCall(i int, result func (fake *FakeActor) GetGlobalStagingSecurityGroups() ([]resources.SecurityGroup, v7action.Warnings, error) { fake.getGlobalStagingSecurityGroupsMutex.Lock() ret, specificReturn := fake.getGlobalStagingSecurityGroupsReturnsOnCall[len(fake.getGlobalStagingSecurityGroupsArgsForCall)] - fake.getGlobalStagingSecurityGroupsArgsForCall = append(fake.getGlobalStagingSecurityGroupsArgsForCall, struct { - }{}) + fake.getGlobalStagingSecurityGroupsArgsForCall = append(fake.getGlobalStagingSecurityGroupsArgsForCall, struct{}{}) stub := fake.GetGlobalStagingSecurityGroupsStub fakeReturns := fake.getGlobalStagingSecurityGroupsReturns fake.recordInvocation("GetGlobalStagingSecurityGroups", []interface{}{}) @@ -10335,8 +11812,7 @@ func (fake *FakeActor) GetGlobalStagingSecurityGroupsReturnsOnCall(i int, result func (fake *FakeActor) GetInfoResponse() (v7action.Info, v7action.Warnings, error) { fake.getInfoResponseMutex.Lock() ret, specificReturn := fake.getInfoResponseReturnsOnCall[len(fake.getInfoResponseArgsForCall)] - fake.getInfoResponseArgsForCall = append(fake.getInfoResponseArgsForCall, struct { - }{}) + fake.getInfoResponseArgsForCall = append(fake.getInfoResponseArgsForCall, struct{}{}) stub := fake.GetInfoResponseStub fakeReturns := fake.getInfoResponseReturns fake.recordInvocation("GetInfoResponse", []interface{}{}) @@ -10394,9 +11870,7 @@ func (fake *FakeActor) GetInfoResponseReturnsOnCall(i int, result1 v7action.Info func (fake *FakeActor) GetIsolationSegmentByName(arg1 string) (resources.IsolationSegment, v7action.Warnings, error) { fake.getIsolationSegmentByNameMutex.Lock() ret, specificReturn := fake.getIsolationSegmentByNameReturnsOnCall[len(fake.getIsolationSegmentByNameArgsForCall)] - fake.getIsolationSegmentByNameArgsForCall = append(fake.getIsolationSegmentByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getIsolationSegmentByNameArgsForCall = append(fake.getIsolationSegmentByNameArgsForCall, FakeActorGetIsolationSegmentByNameArgs{arg1}) stub := fake.GetIsolationSegmentByNameStub fakeReturns := fake.getIsolationSegmentByNameReturns fake.recordInvocation("GetIsolationSegmentByName", []interface{}{arg1}) @@ -10426,7 +11900,15 @@ func (fake *FakeActor) GetIsolationSegmentByNameArgsForCall(i int) string { fake.getIsolationSegmentByNameMutex.RLock() defer fake.getIsolationSegmentByNameMutex.RUnlock() argsForCall := fake.getIsolationSegmentByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetIsolationSegmentByNameArgs() []FakeActorGetIsolationSegmentByNameArgs { + fake.getIsolationSegmentByNameMutex.RLock() + defer fake.getIsolationSegmentByNameMutex.RUnlock() + args := make([]FakeActorGetIsolationSegmentByNameArgs, len(fake.getIsolationSegmentByNameArgsForCall)) + copy(args, fake.getIsolationSegmentByNameArgsForCall) + return args } func (fake *FakeActor) GetIsolationSegmentByNameReturns(result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) { @@ -10461,8 +11943,7 @@ func (fake *FakeActor) GetIsolationSegmentByNameReturnsOnCall(i int, result1 res func (fake *FakeActor) GetIsolationSegmentSummaries() ([]v7action.IsolationSegmentSummary, v7action.Warnings, error) { fake.getIsolationSegmentSummariesMutex.Lock() ret, specificReturn := fake.getIsolationSegmentSummariesReturnsOnCall[len(fake.getIsolationSegmentSummariesArgsForCall)] - fake.getIsolationSegmentSummariesArgsForCall = append(fake.getIsolationSegmentSummariesArgsForCall, struct { - }{}) + fake.getIsolationSegmentSummariesArgsForCall = append(fake.getIsolationSegmentSummariesArgsForCall, struct{}{}) stub := fake.GetIsolationSegmentSummariesStub fakeReturns := fake.getIsolationSegmentSummariesReturns fake.recordInvocation("GetIsolationSegmentSummaries", []interface{}{}) @@ -10520,9 +12001,7 @@ func (fake *FakeActor) GetIsolationSegmentSummariesReturnsOnCall(i int, result1 func (fake *FakeActor) GetIsolationSegmentsByOrganization(arg1 string) ([]resources.IsolationSegment, v7action.Warnings, error) { fake.getIsolationSegmentsByOrganizationMutex.Lock() ret, specificReturn := fake.getIsolationSegmentsByOrganizationReturnsOnCall[len(fake.getIsolationSegmentsByOrganizationArgsForCall)] - fake.getIsolationSegmentsByOrganizationArgsForCall = append(fake.getIsolationSegmentsByOrganizationArgsForCall, struct { - arg1 string - }{arg1}) + fake.getIsolationSegmentsByOrganizationArgsForCall = append(fake.getIsolationSegmentsByOrganizationArgsForCall, FakeActorGetIsolationSegmentsByOrganizationArgs{arg1}) stub := fake.GetIsolationSegmentsByOrganizationStub fakeReturns := fake.getIsolationSegmentsByOrganizationReturns fake.recordInvocation("GetIsolationSegmentsByOrganization", []interface{}{arg1}) @@ -10552,7 +12031,15 @@ func (fake *FakeActor) GetIsolationSegmentsByOrganizationArgsForCall(i int) stri fake.getIsolationSegmentsByOrganizationMutex.RLock() defer fake.getIsolationSegmentsByOrganizationMutex.RUnlock() argsForCall := fake.getIsolationSegmentsByOrganizationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetIsolationSegmentsByOrganizationArgs() []FakeActorGetIsolationSegmentsByOrganizationArgs { + fake.getIsolationSegmentsByOrganizationMutex.RLock() + defer fake.getIsolationSegmentsByOrganizationMutex.RUnlock() + args := make([]FakeActorGetIsolationSegmentsByOrganizationArgs, len(fake.getIsolationSegmentsByOrganizationArgsForCall)) + copy(args, fake.getIsolationSegmentsByOrganizationArgsForCall) + return args } func (fake *FakeActor) GetIsolationSegmentsByOrganizationReturns(result1 []resources.IsolationSegment, result2 v7action.Warnings, result3 error) { @@ -10587,9 +12074,7 @@ func (fake *FakeActor) GetIsolationSegmentsByOrganizationReturnsOnCall(i int, re func (fake *FakeActor) GetLatestActiveDeploymentForApp(arg1 string) (resources.Deployment, v7action.Warnings, error) { fake.getLatestActiveDeploymentForAppMutex.Lock() ret, specificReturn := fake.getLatestActiveDeploymentForAppReturnsOnCall[len(fake.getLatestActiveDeploymentForAppArgsForCall)] - fake.getLatestActiveDeploymentForAppArgsForCall = append(fake.getLatestActiveDeploymentForAppArgsForCall, struct { - arg1 string - }{arg1}) + fake.getLatestActiveDeploymentForAppArgsForCall = append(fake.getLatestActiveDeploymentForAppArgsForCall, FakeActorGetLatestActiveDeploymentForAppArgs{arg1}) stub := fake.GetLatestActiveDeploymentForAppStub fakeReturns := fake.getLatestActiveDeploymentForAppReturns fake.recordInvocation("GetLatestActiveDeploymentForApp", []interface{}{arg1}) @@ -10619,7 +12104,15 @@ func (fake *FakeActor) GetLatestActiveDeploymentForAppArgsForCall(i int) string fake.getLatestActiveDeploymentForAppMutex.RLock() defer fake.getLatestActiveDeploymentForAppMutex.RUnlock() argsForCall := fake.getLatestActiveDeploymentForAppArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetLatestActiveDeploymentForAppArgs() []FakeActorGetLatestActiveDeploymentForAppArgs { + fake.getLatestActiveDeploymentForAppMutex.RLock() + defer fake.getLatestActiveDeploymentForAppMutex.RUnlock() + args := make([]FakeActorGetLatestActiveDeploymentForAppArgs, len(fake.getLatestActiveDeploymentForAppArgsForCall)) + copy(args, fake.getLatestActiveDeploymentForAppArgsForCall) + return args } func (fake *FakeActor) GetLatestActiveDeploymentForAppReturns(result1 resources.Deployment, result2 v7action.Warnings, result3 error) { @@ -10654,8 +12147,7 @@ func (fake *FakeActor) GetLatestActiveDeploymentForAppReturnsOnCall(i int, resul func (fake *FakeActor) GetLoginPrompts() (map[string]coreconfig.AuthPrompt, error) { fake.getLoginPromptsMutex.Lock() ret, specificReturn := fake.getLoginPromptsReturnsOnCall[len(fake.getLoginPromptsArgsForCall)] - fake.getLoginPromptsArgsForCall = append(fake.getLoginPromptsArgsForCall, struct { - }{}) + fake.getLoginPromptsArgsForCall = append(fake.getLoginPromptsArgsForCall, struct{}{}) stub := fake.GetLoginPromptsStub fakeReturns := fake.getLoginPromptsReturns fake.recordInvocation("GetLoginPrompts", []interface{}{}) @@ -10710,9 +12202,7 @@ func (fake *FakeActor) GetLoginPromptsReturnsOnCall(i int, result1 map[string]co func (fake *FakeActor) GetNewestReadyPackageForApplication(arg1 resources.Application) (resources.Package, v7action.Warnings, error) { fake.getNewestReadyPackageForApplicationMutex.Lock() ret, specificReturn := fake.getNewestReadyPackageForApplicationReturnsOnCall[len(fake.getNewestReadyPackageForApplicationArgsForCall)] - fake.getNewestReadyPackageForApplicationArgsForCall = append(fake.getNewestReadyPackageForApplicationArgsForCall, struct { - arg1 resources.Application - }{arg1}) + fake.getNewestReadyPackageForApplicationArgsForCall = append(fake.getNewestReadyPackageForApplicationArgsForCall, FakeActorGetNewestReadyPackageForApplicationArgs{arg1}) stub := fake.GetNewestReadyPackageForApplicationStub fakeReturns := fake.getNewestReadyPackageForApplicationReturns fake.recordInvocation("GetNewestReadyPackageForApplication", []interface{}{arg1}) @@ -10742,7 +12232,15 @@ func (fake *FakeActor) GetNewestReadyPackageForApplicationArgsForCall(i int) res fake.getNewestReadyPackageForApplicationMutex.RLock() defer fake.getNewestReadyPackageForApplicationMutex.RUnlock() argsForCall := fake.getNewestReadyPackageForApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetNewestReadyPackageForApplicationArgs() []FakeActorGetNewestReadyPackageForApplicationArgs { + fake.getNewestReadyPackageForApplicationMutex.RLock() + defer fake.getNewestReadyPackageForApplicationMutex.RUnlock() + args := make([]FakeActorGetNewestReadyPackageForApplicationArgs, len(fake.getNewestReadyPackageForApplicationArgsForCall)) + copy(args, fake.getNewestReadyPackageForApplicationArgsForCall) + return args } func (fake *FakeActor) GetNewestReadyPackageForApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -10777,9 +12275,7 @@ func (fake *FakeActor) GetNewestReadyPackageForApplicationReturnsOnCall(i int, r func (fake *FakeActor) GetOrgUsersByRoleType(arg1 string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) { fake.getOrgUsersByRoleTypeMutex.Lock() ret, specificReturn := fake.getOrgUsersByRoleTypeReturnsOnCall[len(fake.getOrgUsersByRoleTypeArgsForCall)] - fake.getOrgUsersByRoleTypeArgsForCall = append(fake.getOrgUsersByRoleTypeArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrgUsersByRoleTypeArgsForCall = append(fake.getOrgUsersByRoleTypeArgsForCall, FakeActorGetOrgUsersByRoleTypeArgs{arg1}) stub := fake.GetOrgUsersByRoleTypeStub fakeReturns := fake.getOrgUsersByRoleTypeReturns fake.recordInvocation("GetOrgUsersByRoleType", []interface{}{arg1}) @@ -10809,7 +12305,15 @@ func (fake *FakeActor) GetOrgUsersByRoleTypeArgsForCall(i int) string { fake.getOrgUsersByRoleTypeMutex.RLock() defer fake.getOrgUsersByRoleTypeMutex.RUnlock() argsForCall := fake.getOrgUsersByRoleTypeArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrgUsersByRoleTypeArgs() []FakeActorGetOrgUsersByRoleTypeArgs { + fake.getOrgUsersByRoleTypeMutex.RLock() + defer fake.getOrgUsersByRoleTypeMutex.RUnlock() + args := make([]FakeActorGetOrgUsersByRoleTypeArgs, len(fake.getOrgUsersByRoleTypeArgsForCall)) + copy(args, fake.getOrgUsersByRoleTypeArgsForCall) + return args } func (fake *FakeActor) GetOrgUsersByRoleTypeReturns(result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) { @@ -10844,9 +12348,7 @@ func (fake *FakeActor) GetOrgUsersByRoleTypeReturnsOnCall(i int, result1 map[con func (fake *FakeActor) GetOrganizationByName(arg1 string) (resources.Organization, v7action.Warnings, error) { fake.getOrganizationByNameMutex.Lock() ret, specificReturn := fake.getOrganizationByNameReturnsOnCall[len(fake.getOrganizationByNameArgsForCall)] - fake.getOrganizationByNameArgsForCall = append(fake.getOrganizationByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationByNameArgsForCall = append(fake.getOrganizationByNameArgsForCall, FakeActorGetOrganizationByNameArgs{arg1}) stub := fake.GetOrganizationByNameStub fakeReturns := fake.getOrganizationByNameReturns fake.recordInvocation("GetOrganizationByName", []interface{}{arg1}) @@ -10876,7 +12378,15 @@ func (fake *FakeActor) GetOrganizationByNameArgsForCall(i int) string { fake.getOrganizationByNameMutex.RLock() defer fake.getOrganizationByNameMutex.RUnlock() argsForCall := fake.getOrganizationByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationByNameArgs() []FakeActorGetOrganizationByNameArgs { + fake.getOrganizationByNameMutex.RLock() + defer fake.getOrganizationByNameMutex.RUnlock() + args := make([]FakeActorGetOrganizationByNameArgs, len(fake.getOrganizationByNameArgsForCall)) + copy(args, fake.getOrganizationByNameArgsForCall) + return args } func (fake *FakeActor) GetOrganizationByNameReturns(result1 resources.Organization, result2 v7action.Warnings, result3 error) { @@ -10911,10 +12421,7 @@ func (fake *FakeActor) GetOrganizationByNameReturnsOnCall(i int, result1 resourc func (fake *FakeActor) GetOrganizationDomains(arg1 string, arg2 string) ([]resources.Domain, v7action.Warnings, error) { fake.getOrganizationDomainsMutex.Lock() ret, specificReturn := fake.getOrganizationDomainsReturnsOnCall[len(fake.getOrganizationDomainsArgsForCall)] - fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, FakeActorGetOrganizationDomainsArgs{arg1, arg2}) stub := fake.GetOrganizationDomainsStub fakeReturns := fake.getOrganizationDomainsReturns fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2}) @@ -10944,7 +12451,15 @@ func (fake *FakeActor) GetOrganizationDomainsArgsForCall(i int) (string, string) fake.getOrganizationDomainsMutex.RLock() defer fake.getOrganizationDomainsMutex.RUnlock() argsForCall := fake.getOrganizationDomainsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetOrganizationDomainsArgs() []FakeActorGetOrganizationDomainsArgs { + fake.getOrganizationDomainsMutex.RLock() + defer fake.getOrganizationDomainsMutex.RUnlock() + args := make([]FakeActorGetOrganizationDomainsArgs, len(fake.getOrganizationDomainsArgsForCall)) + copy(args, fake.getOrganizationDomainsArgsForCall) + return args } func (fake *FakeActor) GetOrganizationDomainsReturns(result1 []resources.Domain, result2 v7action.Warnings, result3 error) { @@ -10979,9 +12494,7 @@ func (fake *FakeActor) GetOrganizationDomainsReturnsOnCall(i int, result1 []reso func (fake *FakeActor) GetOrganizationLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getOrganizationLabelsMutex.Lock() ret, specificReturn := fake.getOrganizationLabelsReturnsOnCall[len(fake.getOrganizationLabelsArgsForCall)] - fake.getOrganizationLabelsArgsForCall = append(fake.getOrganizationLabelsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationLabelsArgsForCall = append(fake.getOrganizationLabelsArgsForCall, FakeActorGetOrganizationLabelsArgs{arg1}) stub := fake.GetOrganizationLabelsStub fakeReturns := fake.getOrganizationLabelsReturns fake.recordInvocation("GetOrganizationLabels", []interface{}{arg1}) @@ -11011,7 +12524,15 @@ func (fake *FakeActor) GetOrganizationLabelsArgsForCall(i int) string { fake.getOrganizationLabelsMutex.RLock() defer fake.getOrganizationLabelsMutex.RUnlock() argsForCall := fake.getOrganizationLabelsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationLabelsArgs() []FakeActorGetOrganizationLabelsArgs { + fake.getOrganizationLabelsMutex.RLock() + defer fake.getOrganizationLabelsMutex.RUnlock() + args := make([]FakeActorGetOrganizationLabelsArgs, len(fake.getOrganizationLabelsArgsForCall)) + copy(args, fake.getOrganizationLabelsArgsForCall) + return args } func (fake *FakeActor) GetOrganizationLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -11046,9 +12567,7 @@ func (fake *FakeActor) GetOrganizationLabelsReturnsOnCall(i int, result1 map[str func (fake *FakeActor) GetOrganizationQuotaByName(arg1 string) (resources.OrganizationQuota, v7action.Warnings, error) { fake.getOrganizationQuotaByNameMutex.Lock() ret, specificReturn := fake.getOrganizationQuotaByNameReturnsOnCall[len(fake.getOrganizationQuotaByNameArgsForCall)] - fake.getOrganizationQuotaByNameArgsForCall = append(fake.getOrganizationQuotaByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationQuotaByNameArgsForCall = append(fake.getOrganizationQuotaByNameArgsForCall, FakeActorGetOrganizationQuotaByNameArgs{arg1}) stub := fake.GetOrganizationQuotaByNameStub fakeReturns := fake.getOrganizationQuotaByNameReturns fake.recordInvocation("GetOrganizationQuotaByName", []interface{}{arg1}) @@ -11078,7 +12597,15 @@ func (fake *FakeActor) GetOrganizationQuotaByNameArgsForCall(i int) string { fake.getOrganizationQuotaByNameMutex.RLock() defer fake.getOrganizationQuotaByNameMutex.RUnlock() argsForCall := fake.getOrganizationQuotaByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationQuotaByNameArgs() []FakeActorGetOrganizationQuotaByNameArgs { + fake.getOrganizationQuotaByNameMutex.RLock() + defer fake.getOrganizationQuotaByNameMutex.RUnlock() + args := make([]FakeActorGetOrganizationQuotaByNameArgs, len(fake.getOrganizationQuotaByNameArgsForCall)) + copy(args, fake.getOrganizationQuotaByNameArgsForCall) + return args } func (fake *FakeActor) GetOrganizationQuotaByNameReturns(result1 resources.OrganizationQuota, result2 v7action.Warnings, result3 error) { @@ -11113,8 +12640,7 @@ func (fake *FakeActor) GetOrganizationQuotaByNameReturnsOnCall(i int, result1 re func (fake *FakeActor) GetOrganizationQuotas() ([]resources.OrganizationQuota, v7action.Warnings, error) { fake.getOrganizationQuotasMutex.Lock() ret, specificReturn := fake.getOrganizationQuotasReturnsOnCall[len(fake.getOrganizationQuotasArgsForCall)] - fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, struct { - }{}) + fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, struct{}{}) stub := fake.GetOrganizationQuotasStub fakeReturns := fake.getOrganizationQuotasReturns fake.recordInvocation("GetOrganizationQuotas", []interface{}{}) @@ -11172,9 +12698,7 @@ func (fake *FakeActor) GetOrganizationQuotasReturnsOnCall(i int, result1 []resou func (fake *FakeActor) GetOrganizationSpaces(arg1 string) ([]resources.Space, v7action.Warnings, error) { fake.getOrganizationSpacesMutex.Lock() ret, specificReturn := fake.getOrganizationSpacesReturnsOnCall[len(fake.getOrganizationSpacesArgsForCall)] - fake.getOrganizationSpacesArgsForCall = append(fake.getOrganizationSpacesArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationSpacesArgsForCall = append(fake.getOrganizationSpacesArgsForCall, FakeActorGetOrganizationSpacesArgs{arg1}) stub := fake.GetOrganizationSpacesStub fakeReturns := fake.getOrganizationSpacesReturns fake.recordInvocation("GetOrganizationSpaces", []interface{}{arg1}) @@ -11204,7 +12728,15 @@ func (fake *FakeActor) GetOrganizationSpacesArgsForCall(i int) string { fake.getOrganizationSpacesMutex.RLock() defer fake.getOrganizationSpacesMutex.RUnlock() argsForCall := fake.getOrganizationSpacesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationSpacesArgs() []FakeActorGetOrganizationSpacesArgs { + fake.getOrganizationSpacesMutex.RLock() + defer fake.getOrganizationSpacesMutex.RUnlock() + args := make([]FakeActorGetOrganizationSpacesArgs, len(fake.getOrganizationSpacesArgsForCall)) + copy(args, fake.getOrganizationSpacesArgsForCall) + return args } func (fake *FakeActor) GetOrganizationSpacesReturns(result1 []resources.Space, result2 v7action.Warnings, result3 error) { @@ -11239,10 +12771,7 @@ func (fake *FakeActor) GetOrganizationSpacesReturnsOnCall(i int, result1 []resou func (fake *FakeActor) GetOrganizationSpacesWithLabelSelector(arg1 string, arg2 string) ([]resources.Space, v7action.Warnings, error) { fake.getOrganizationSpacesWithLabelSelectorMutex.Lock() ret, specificReturn := fake.getOrganizationSpacesWithLabelSelectorReturnsOnCall[len(fake.getOrganizationSpacesWithLabelSelectorArgsForCall)] - fake.getOrganizationSpacesWithLabelSelectorArgsForCall = append(fake.getOrganizationSpacesWithLabelSelectorArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getOrganizationSpacesWithLabelSelectorArgsForCall = append(fake.getOrganizationSpacesWithLabelSelectorArgsForCall, FakeActorGetOrganizationSpacesWithLabelSelectorArgs{arg1, arg2}) stub := fake.GetOrganizationSpacesWithLabelSelectorStub fakeReturns := fake.getOrganizationSpacesWithLabelSelectorReturns fake.recordInvocation("GetOrganizationSpacesWithLabelSelector", []interface{}{arg1, arg2}) @@ -11272,7 +12801,15 @@ func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorArgsForCall(i int) fake.getOrganizationSpacesWithLabelSelectorMutex.RLock() defer fake.getOrganizationSpacesWithLabelSelectorMutex.RUnlock() argsForCall := fake.getOrganizationSpacesWithLabelSelectorArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorArgs() []FakeActorGetOrganizationSpacesWithLabelSelectorArgs { + fake.getOrganizationSpacesWithLabelSelectorMutex.RLock() + defer fake.getOrganizationSpacesWithLabelSelectorMutex.RUnlock() + args := make([]FakeActorGetOrganizationSpacesWithLabelSelectorArgs, len(fake.getOrganizationSpacesWithLabelSelectorArgsForCall)) + copy(args, fake.getOrganizationSpacesWithLabelSelectorArgsForCall) + return args } func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorReturns(result1 []resources.Space, result2 v7action.Warnings, result3 error) { @@ -11307,9 +12844,7 @@ func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorReturnsOnCall(i int func (fake *FakeActor) GetOrganizationSummaryByName(arg1 string) (v7action.OrganizationSummary, v7action.Warnings, error) { fake.getOrganizationSummaryByNameMutex.Lock() ret, specificReturn := fake.getOrganizationSummaryByNameReturnsOnCall[len(fake.getOrganizationSummaryByNameArgsForCall)] - fake.getOrganizationSummaryByNameArgsForCall = append(fake.getOrganizationSummaryByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationSummaryByNameArgsForCall = append(fake.getOrganizationSummaryByNameArgsForCall, FakeActorGetOrganizationSummaryByNameArgs{arg1}) stub := fake.GetOrganizationSummaryByNameStub fakeReturns := fake.getOrganizationSummaryByNameReturns fake.recordInvocation("GetOrganizationSummaryByName", []interface{}{arg1}) @@ -11339,7 +12874,15 @@ func (fake *FakeActor) GetOrganizationSummaryByNameArgsForCall(i int) string { fake.getOrganizationSummaryByNameMutex.RLock() defer fake.getOrganizationSummaryByNameMutex.RUnlock() argsForCall := fake.getOrganizationSummaryByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationSummaryByNameArgs() []FakeActorGetOrganizationSummaryByNameArgs { + fake.getOrganizationSummaryByNameMutex.RLock() + defer fake.getOrganizationSummaryByNameMutex.RUnlock() + args := make([]FakeActorGetOrganizationSummaryByNameArgs, len(fake.getOrganizationSummaryByNameArgsForCall)) + copy(args, fake.getOrganizationSummaryByNameArgsForCall) + return args } func (fake *FakeActor) GetOrganizationSummaryByNameReturns(result1 v7action.OrganizationSummary, result2 v7action.Warnings, result3 error) { @@ -11374,9 +12917,7 @@ func (fake *FakeActor) GetOrganizationSummaryByNameReturnsOnCall(i int, result1 func (fake *FakeActor) GetOrganizations(arg1 string) ([]resources.Organization, v7action.Warnings, error) { fake.getOrganizationsMutex.Lock() ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)] - fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, FakeActorGetOrganizationsArgs{arg1}) stub := fake.GetOrganizationsStub fakeReturns := fake.getOrganizationsReturns fake.recordInvocation("GetOrganizations", []interface{}{arg1}) @@ -11406,7 +12947,15 @@ func (fake *FakeActor) GetOrganizationsArgsForCall(i int) string { fake.getOrganizationsMutex.RLock() defer fake.getOrganizationsMutex.RUnlock() argsForCall := fake.getOrganizationsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetOrganizationsArgs() []FakeActorGetOrganizationsArgs { + fake.getOrganizationsMutex.RLock() + defer fake.getOrganizationsMutex.RUnlock() + args := make([]FakeActorGetOrganizationsArgs, len(fake.getOrganizationsArgsForCall)) + copy(args, fake.getOrganizationsArgsForCall) + return args } func (fake *FakeActor) GetOrganizationsReturns(result1 []resources.Organization, result2 v7action.Warnings, result3 error) { @@ -11441,10 +12990,7 @@ func (fake *FakeActor) GetOrganizationsReturnsOnCall(i int, result1 []resources. func (fake *FakeActor) GetProcessByTypeAndApplication(arg1 string, arg2 string) (resources.Process, v7action.Warnings, error) { fake.getProcessByTypeAndApplicationMutex.Lock() ret, specificReturn := fake.getProcessByTypeAndApplicationReturnsOnCall[len(fake.getProcessByTypeAndApplicationArgsForCall)] - fake.getProcessByTypeAndApplicationArgsForCall = append(fake.getProcessByTypeAndApplicationArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getProcessByTypeAndApplicationArgsForCall = append(fake.getProcessByTypeAndApplicationArgsForCall, FakeActorGetProcessByTypeAndApplicationArgs{arg1, arg2}) stub := fake.GetProcessByTypeAndApplicationStub fakeReturns := fake.getProcessByTypeAndApplicationReturns fake.recordInvocation("GetProcessByTypeAndApplication", []interface{}{arg1, arg2}) @@ -11474,7 +13020,15 @@ func (fake *FakeActor) GetProcessByTypeAndApplicationArgsForCall(i int) (string, fake.getProcessByTypeAndApplicationMutex.RLock() defer fake.getProcessByTypeAndApplicationMutex.RUnlock() argsForCall := fake.getProcessByTypeAndApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetProcessByTypeAndApplicationArgs() []FakeActorGetProcessByTypeAndApplicationArgs { + fake.getProcessByTypeAndApplicationMutex.RLock() + defer fake.getProcessByTypeAndApplicationMutex.RUnlock() + args := make([]FakeActorGetProcessByTypeAndApplicationArgs, len(fake.getProcessByTypeAndApplicationArgsForCall)) + copy(args, fake.getProcessByTypeAndApplicationArgsForCall) + return args } func (fake *FakeActor) GetProcessByTypeAndApplicationReturns(result1 resources.Process, result2 v7action.Warnings, result3 error) { @@ -11509,10 +13063,7 @@ func (fake *FakeActor) GetProcessByTypeAndApplicationReturnsOnCall(i int, result func (fake *FakeActor) GetRawApplicationManifestByNameAndSpace(arg1 string, arg2 string) ([]byte, v7action.Warnings, error) { fake.getRawApplicationManifestByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getRawApplicationManifestByNameAndSpaceReturnsOnCall[len(fake.getRawApplicationManifestByNameAndSpaceArgsForCall)] - fake.getRawApplicationManifestByNameAndSpaceArgsForCall = append(fake.getRawApplicationManifestByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRawApplicationManifestByNameAndSpaceArgsForCall = append(fake.getRawApplicationManifestByNameAndSpaceArgsForCall, FakeActorGetRawApplicationManifestByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetRawApplicationManifestByNameAndSpaceStub fakeReturns := fake.getRawApplicationManifestByNameAndSpaceReturns fake.recordInvocation("GetRawApplicationManifestByNameAndSpace", []interface{}{arg1, arg2}) @@ -11542,7 +13093,15 @@ func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceArgsForCall(i int) fake.getRawApplicationManifestByNameAndSpaceMutex.RLock() defer fake.getRawApplicationManifestByNameAndSpaceMutex.RUnlock() argsForCall := fake.getRawApplicationManifestByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceArgs() []FakeActorGetRawApplicationManifestByNameAndSpaceArgs { + fake.getRawApplicationManifestByNameAndSpaceMutex.RLock() + defer fake.getRawApplicationManifestByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetRawApplicationManifestByNameAndSpaceArgs, len(fake.getRawApplicationManifestByNameAndSpaceArgsForCall)) + copy(args, fake.getRawApplicationManifestByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceReturns(result1 []byte, result2 v7action.Warnings, result3 error) { @@ -11577,10 +13136,7 @@ func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceReturnsOnCall(i in func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpace(arg1 string, arg2 string) ([]v7action.Event, v7action.Warnings, error) { fake.getRecentEventsByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.getRecentEventsByApplicationNameAndSpaceReturnsOnCall[len(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall)] - fake.getRecentEventsByApplicationNameAndSpaceArgsForCall = append(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRecentEventsByApplicationNameAndSpaceArgsForCall = append(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall, FakeActorGetRecentEventsByApplicationNameAndSpaceArgs{arg1, arg2}) stub := fake.GetRecentEventsByApplicationNameAndSpaceStub fakeReturns := fake.getRecentEventsByApplicationNameAndSpaceReturns fake.recordInvocation("GetRecentEventsByApplicationNameAndSpace", []interface{}{arg1, arg2}) @@ -11610,7 +13166,15 @@ func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceArgsForCall(i int fake.getRecentEventsByApplicationNameAndSpaceMutex.RLock() defer fake.getRecentEventsByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.getRecentEventsByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceArgs() []FakeActorGetRecentEventsByApplicationNameAndSpaceArgs { + fake.getRecentEventsByApplicationNameAndSpaceMutex.RLock() + defer fake.getRecentEventsByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetRecentEventsByApplicationNameAndSpaceArgs, len(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.getRecentEventsByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceReturns(result1 []v7action.Event, result2 v7action.Warnings, result3 error) { @@ -11645,11 +13209,7 @@ func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceReturnsOnCall(i i func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpace(arg1 string, arg2 string, arg3 sharedaction.LogCacheClient) ([]sharedaction.LogMessage, v7action.Warnings, error) { fake.getRecentLogsForApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getRecentLogsForApplicationByNameAndSpaceReturnsOnCall[len(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall)] - fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 sharedaction.LogCacheClient - }{arg1, arg2, arg3}) + fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall, FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.GetRecentLogsForApplicationByNameAndSpaceStub fakeReturns := fake.getRecentLogsForApplicationByNameAndSpaceReturns fake.recordInvocation("GetRecentLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -11679,7 +13239,15 @@ func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceArgsForCall(i in fake.getRecentLogsForApplicationByNameAndSpaceMutex.RLock() defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.RUnlock() argsForCall := fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceArgs() []FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs { + fake.getRecentLogsForApplicationByNameAndSpaceMutex.RLock() + defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetRecentLogsForApplicationByNameAndSpaceArgs, len(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall)) + copy(args, fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceReturns(result1 []sharedaction.LogMessage, result2 v7action.Warnings, result3 error) { @@ -11714,10 +13282,7 @@ func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceReturnsOnCall(i func (fake *FakeActor) GetRevisionByApplicationAndVersion(arg1 string, arg2 int) (resources.Revision, v7action.Warnings, error) { fake.getRevisionByApplicationAndVersionMutex.Lock() ret, specificReturn := fake.getRevisionByApplicationAndVersionReturnsOnCall[len(fake.getRevisionByApplicationAndVersionArgsForCall)] - fake.getRevisionByApplicationAndVersionArgsForCall = append(fake.getRevisionByApplicationAndVersionArgsForCall, struct { - arg1 string - arg2 int - }{arg1, arg2}) + fake.getRevisionByApplicationAndVersionArgsForCall = append(fake.getRevisionByApplicationAndVersionArgsForCall, FakeActorGetRevisionByApplicationAndVersionArgs{arg1, arg2}) stub := fake.GetRevisionByApplicationAndVersionStub fakeReturns := fake.getRevisionByApplicationAndVersionReturns fake.recordInvocation("GetRevisionByApplicationAndVersion", []interface{}{arg1, arg2}) @@ -11747,7 +13312,15 @@ func (fake *FakeActor) GetRevisionByApplicationAndVersionArgsForCall(i int) (str fake.getRevisionByApplicationAndVersionMutex.RLock() defer fake.getRevisionByApplicationAndVersionMutex.RUnlock() argsForCall := fake.getRevisionByApplicationAndVersionArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRevisionByApplicationAndVersionArgs() []FakeActorGetRevisionByApplicationAndVersionArgs { + fake.getRevisionByApplicationAndVersionMutex.RLock() + defer fake.getRevisionByApplicationAndVersionMutex.RUnlock() + args := make([]FakeActorGetRevisionByApplicationAndVersionArgs, len(fake.getRevisionByApplicationAndVersionArgsForCall)) + copy(args, fake.getRevisionByApplicationAndVersionArgsForCall) + return args } func (fake *FakeActor) GetRevisionByApplicationAndVersionReturns(result1 resources.Revision, result2 v7action.Warnings, result3 error) { @@ -11782,10 +13355,7 @@ func (fake *FakeActor) GetRevisionByApplicationAndVersionReturnsOnCall(i int, re func (fake *FakeActor) GetRevisionsByApplicationNameAndSpace(arg1 string, arg2 string) ([]resources.Revision, v7action.Warnings, error) { fake.getRevisionsByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.getRevisionsByApplicationNameAndSpaceReturnsOnCall[len(fake.getRevisionsByApplicationNameAndSpaceArgsForCall)] - fake.getRevisionsByApplicationNameAndSpaceArgsForCall = append(fake.getRevisionsByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRevisionsByApplicationNameAndSpaceArgsForCall = append(fake.getRevisionsByApplicationNameAndSpaceArgsForCall, FakeActorGetRevisionsByApplicationNameAndSpaceArgs{arg1, arg2}) stub := fake.GetRevisionsByApplicationNameAndSpaceStub fakeReturns := fake.getRevisionsByApplicationNameAndSpaceReturns fake.recordInvocation("GetRevisionsByApplicationNameAndSpace", []interface{}{arg1, arg2}) @@ -11815,7 +13385,15 @@ func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceArgsForCall(i int) ( fake.getRevisionsByApplicationNameAndSpaceMutex.RLock() defer fake.getRevisionsByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.getRevisionsByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceArgs() []FakeActorGetRevisionsByApplicationNameAndSpaceArgs { + fake.getRevisionsByApplicationNameAndSpaceMutex.RLock() + defer fake.getRevisionsByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetRevisionsByApplicationNameAndSpaceArgs, len(fake.getRevisionsByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.getRevisionsByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceReturns(result1 []resources.Revision, result2 v7action.Warnings, result3 error) { @@ -11850,8 +13428,7 @@ func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceReturnsOnCall(i int, func (fake *FakeActor) GetRootResponse() (v7action.Root, v7action.Warnings, error) { fake.getRootResponseMutex.Lock() ret, specificReturn := fake.getRootResponseReturnsOnCall[len(fake.getRootResponseArgsForCall)] - fake.getRootResponseArgsForCall = append(fake.getRootResponseArgsForCall, struct { - }{}) + fake.getRootResponseArgsForCall = append(fake.getRootResponseArgsForCall, struct{}{}) stub := fake.GetRootResponseStub fakeReturns := fake.getRootResponseReturns fake.recordInvocation("GetRootResponse", []interface{}{}) @@ -11909,12 +13486,7 @@ func (fake *FakeActor) GetRootResponseReturnsOnCall(i int, result1 v7action.Root func (fake *FakeActor) GetRouteByAttributes(arg1 resources.Domain, arg2 string, arg3 string, arg4 int) (resources.Route, v7action.Warnings, error) { fake.getRouteByAttributesMutex.Lock() ret, specificReturn := fake.getRouteByAttributesReturnsOnCall[len(fake.getRouteByAttributesArgsForCall)] - fake.getRouteByAttributesArgsForCall = append(fake.getRouteByAttributesArgsForCall, struct { - arg1 resources.Domain - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.getRouteByAttributesArgsForCall = append(fake.getRouteByAttributesArgsForCall, FakeActorGetRouteByAttributesArgs{arg1, arg2, arg3, arg4}) stub := fake.GetRouteByAttributesStub fakeReturns := fake.getRouteByAttributesReturns fake.recordInvocation("GetRouteByAttributes", []interface{}{arg1, arg2, arg3, arg4}) @@ -11944,7 +13516,15 @@ func (fake *FakeActor) GetRouteByAttributesArgsForCall(i int) (resources.Domain, fake.getRouteByAttributesMutex.RLock() defer fake.getRouteByAttributesMutex.RUnlock() argsForCall := fake.getRouteByAttributesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) GetRouteByAttributesArgs() []FakeActorGetRouteByAttributesArgs { + fake.getRouteByAttributesMutex.RLock() + defer fake.getRouteByAttributesMutex.RUnlock() + args := make([]FakeActorGetRouteByAttributesArgs, len(fake.getRouteByAttributesArgsForCall)) + copy(args, fake.getRouteByAttributesArgsForCall) + return args } func (fake *FakeActor) GetRouteByAttributesReturns(result1 resources.Route, result2 v7action.Warnings, result3 error) { @@ -11979,10 +13559,7 @@ func (fake *FakeActor) GetRouteByAttributesReturnsOnCall(i int, result1 resource func (fake *FakeActor) GetRouteDestinationByAppGUID(arg1 resources.Route, arg2 string) (resources.RouteDestination, error) { fake.getRouteDestinationByAppGUIDMutex.Lock() ret, specificReturn := fake.getRouteDestinationByAppGUIDReturnsOnCall[len(fake.getRouteDestinationByAppGUIDArgsForCall)] - fake.getRouteDestinationByAppGUIDArgsForCall = append(fake.getRouteDestinationByAppGUIDArgsForCall, struct { - arg1 resources.Route - arg2 string - }{arg1, arg2}) + fake.getRouteDestinationByAppGUIDArgsForCall = append(fake.getRouteDestinationByAppGUIDArgsForCall, FakeActorGetRouteDestinationByAppGUIDArgs{arg1, arg2}) stub := fake.GetRouteDestinationByAppGUIDStub fakeReturns := fake.getRouteDestinationByAppGUIDReturns fake.recordInvocation("GetRouteDestinationByAppGUID", []interface{}{arg1, arg2}) @@ -12012,7 +13589,15 @@ func (fake *FakeActor) GetRouteDestinationByAppGUIDArgsForCall(i int) (resources fake.getRouteDestinationByAppGUIDMutex.RLock() defer fake.getRouteDestinationByAppGUIDMutex.RUnlock() argsForCall := fake.getRouteDestinationByAppGUIDArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRouteDestinationByAppGUIDArgs() []FakeActorGetRouteDestinationByAppGUIDArgs { + fake.getRouteDestinationByAppGUIDMutex.RLock() + defer fake.getRouteDestinationByAppGUIDMutex.RUnlock() + args := make([]FakeActorGetRouteDestinationByAppGUIDArgs, len(fake.getRouteDestinationByAppGUIDArgsForCall)) + copy(args, fake.getRouteDestinationByAppGUIDArgsForCall) + return args } func (fake *FakeActor) GetRouteDestinationByAppGUIDReturns(result1 resources.RouteDestination, result2 error) { @@ -12044,10 +13629,7 @@ func (fake *FakeActor) GetRouteDestinationByAppGUIDReturnsOnCall(i int, result1 func (fake *FakeActor) GetRouteLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getRouteLabelsMutex.Lock() ret, specificReturn := fake.getRouteLabelsReturnsOnCall[len(fake.getRouteLabelsArgsForCall)] - fake.getRouteLabelsArgsForCall = append(fake.getRouteLabelsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRouteLabelsArgsForCall = append(fake.getRouteLabelsArgsForCall, FakeActorGetRouteLabelsArgs{arg1, arg2}) stub := fake.GetRouteLabelsStub fakeReturns := fake.getRouteLabelsReturns fake.recordInvocation("GetRouteLabels", []interface{}{arg1, arg2}) @@ -12077,7 +13659,15 @@ func (fake *FakeActor) GetRouteLabelsArgsForCall(i int) (string, string) { fake.getRouteLabelsMutex.RLock() defer fake.getRouteLabelsMutex.RUnlock() argsForCall := fake.getRouteLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRouteLabelsArgs() []FakeActorGetRouteLabelsArgs { + fake.getRouteLabelsMutex.RLock() + defer fake.getRouteLabelsMutex.RUnlock() + args := make([]FakeActorGetRouteLabelsArgs, len(fake.getRouteLabelsArgsForCall)) + copy(args, fake.getRouteLabelsArgsForCall) + return args } func (fake *FakeActor) GetRouteLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -12112,11 +13702,7 @@ func (fake *FakeActor) GetRouteLabelsReturnsOnCall(i int, result1 map[string]typ func (fake *FakeActor) GetRoutePoliciesByRoute(arg1 string, arg2 string, arg3 string) ([]resources.RoutePolicy, v7action.Warnings, error) { fake.getRoutePoliciesByRouteMutex.Lock() ret, specificReturn := fake.getRoutePoliciesByRouteReturnsOnCall[len(fake.getRoutePoliciesByRouteArgsForCall)] - fake.getRoutePoliciesByRouteArgsForCall = append(fake.getRoutePoliciesByRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getRoutePoliciesByRouteArgsForCall = append(fake.getRoutePoliciesByRouteArgsForCall, FakeActorGetRoutePoliciesByRouteArgs{arg1, arg2, arg3}) stub := fake.GetRoutePoliciesByRouteStub fakeReturns := fake.getRoutePoliciesByRouteReturns fake.recordInvocation("GetRoutePoliciesByRoute", []interface{}{arg1, arg2, arg3}) @@ -12146,7 +13732,15 @@ func (fake *FakeActor) GetRoutePoliciesByRouteArgsForCall(i int) (string, string fake.getRoutePoliciesByRouteMutex.RLock() defer fake.getRoutePoliciesByRouteMutex.RUnlock() argsForCall := fake.getRoutePoliciesByRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetRoutePoliciesByRouteArgs() []FakeActorGetRoutePoliciesByRouteArgs { + fake.getRoutePoliciesByRouteMutex.RLock() + defer fake.getRoutePoliciesByRouteMutex.RUnlock() + args := make([]FakeActorGetRoutePoliciesByRouteArgs, len(fake.getRoutePoliciesByRouteArgsForCall)) + copy(args, fake.getRoutePoliciesByRouteArgsForCall) + return args } func (fake *FakeActor) GetRoutePoliciesByRouteReturns(result1 []resources.RoutePolicy, result2 v7action.Warnings, result3 error) { @@ -12181,13 +13775,7 @@ func (fake *FakeActor) GetRoutePoliciesByRouteReturnsOnCall(i int, result1 []res func (fake *FakeActor) GetRoutePoliciesForSpace(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string) ([]v7action.RoutePolicyWithRoute, v7action.Warnings, error) { fake.getRoutePoliciesForSpaceMutex.Lock() ret, specificReturn := fake.getRoutePoliciesForSpaceReturnsOnCall[len(fake.getRoutePoliciesForSpaceArgsForCall)] - fake.getRoutePoliciesForSpaceArgsForCall = append(fake.getRoutePoliciesForSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 string - arg5 string - }{arg1, arg2, arg3, arg4, arg5}) + fake.getRoutePoliciesForSpaceArgsForCall = append(fake.getRoutePoliciesForSpaceArgsForCall, FakeActorGetRoutePoliciesForSpaceArgs{arg1, arg2, arg3, arg4, arg5}) stub := fake.GetRoutePoliciesForSpaceStub fakeReturns := fake.getRoutePoliciesForSpaceReturns fake.recordInvocation("GetRoutePoliciesForSpace", []interface{}{arg1, arg2, arg3, arg4, arg5}) @@ -12217,7 +13805,15 @@ func (fake *FakeActor) GetRoutePoliciesForSpaceArgsForCall(i int) (string, strin fake.getRoutePoliciesForSpaceMutex.RLock() defer fake.getRoutePoliciesForSpaceMutex.RUnlock() argsForCall := fake.getRoutePoliciesForSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) GetRoutePoliciesForSpaceArgs() []FakeActorGetRoutePoliciesForSpaceArgs { + fake.getRoutePoliciesForSpaceMutex.RLock() + defer fake.getRoutePoliciesForSpaceMutex.RUnlock() + args := make([]FakeActorGetRoutePoliciesForSpaceArgs, len(fake.getRoutePoliciesForSpaceArgsForCall)) + copy(args, fake.getRoutePoliciesForSpaceArgsForCall) + return args } func (fake *FakeActor) GetRoutePoliciesForSpaceReturns(result1 []v7action.RoutePolicyWithRoute, result2 v7action.Warnings, result3 error) { @@ -12252,11 +13848,7 @@ func (fake *FakeActor) GetRoutePoliciesForSpaceReturnsOnCall(i int, result1 []v7 func (fake *FakeActor) GetRoutePolicyLabels(arg1 string, arg2 string, arg3 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getRoutePolicyLabelsMutex.Lock() ret, specificReturn := fake.getRoutePolicyLabelsReturnsOnCall[len(fake.getRoutePolicyLabelsArgsForCall)] - fake.getRoutePolicyLabelsArgsForCall = append(fake.getRoutePolicyLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getRoutePolicyLabelsArgsForCall = append(fake.getRoutePolicyLabelsArgsForCall, FakeActorGetRoutePolicyLabelsArgs{arg1, arg2, arg3}) stub := fake.GetRoutePolicyLabelsStub fakeReturns := fake.getRoutePolicyLabelsReturns fake.recordInvocation("GetRoutePolicyLabels", []interface{}{arg1, arg2, arg3}) @@ -12286,7 +13878,15 @@ func (fake *FakeActor) GetRoutePolicyLabelsArgsForCall(i int) (string, string, s fake.getRoutePolicyLabelsMutex.RLock() defer fake.getRoutePolicyLabelsMutex.RUnlock() argsForCall := fake.getRoutePolicyLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetRoutePolicyLabelsArgs() []FakeActorGetRoutePolicyLabelsArgs { + fake.getRoutePolicyLabelsMutex.RLock() + defer fake.getRoutePolicyLabelsMutex.RUnlock() + args := make([]FakeActorGetRoutePolicyLabelsArgs, len(fake.getRoutePolicyLabelsArgsForCall)) + copy(args, fake.getRoutePolicyLabelsArgsForCall) + return args } func (fake *FakeActor) GetRoutePolicyLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -12326,9 +13926,7 @@ func (fake *FakeActor) GetRouteSummaries(arg1 []resources.Route) ([]v7action.Rou } fake.getRouteSummariesMutex.Lock() ret, specificReturn := fake.getRouteSummariesReturnsOnCall[len(fake.getRouteSummariesArgsForCall)] - fake.getRouteSummariesArgsForCall = append(fake.getRouteSummariesArgsForCall, struct { - arg1 []resources.Route - }{arg1Copy}) + fake.getRouteSummariesArgsForCall = append(fake.getRouteSummariesArgsForCall, FakeActorGetRouteSummariesArgs{arg1Copy}) stub := fake.GetRouteSummariesStub fakeReturns := fake.getRouteSummariesReturns fake.recordInvocation("GetRouteSummaries", []interface{}{arg1Copy}) @@ -12358,7 +13956,15 @@ func (fake *FakeActor) GetRouteSummariesArgsForCall(i int) []resources.Route { fake.getRouteSummariesMutex.RLock() defer fake.getRouteSummariesMutex.RUnlock() argsForCall := fake.getRouteSummariesArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetRouteSummariesArgs() []FakeActorGetRouteSummariesArgs { + fake.getRouteSummariesMutex.RLock() + defer fake.getRouteSummariesMutex.RUnlock() + args := make([]FakeActorGetRouteSummariesArgs, len(fake.getRouteSummariesArgsForCall)) + copy(args, fake.getRouteSummariesArgsForCall) + return args } func (fake *FakeActor) GetRouteSummariesReturns(result1 []v7action.RouteSummary, result2 v7action.Warnings, result3 error) { @@ -12393,8 +13999,7 @@ func (fake *FakeActor) GetRouteSummariesReturnsOnCall(i int, result1 []v7action. func (fake *FakeActor) GetRouterGroups() ([]v7action.RouterGroup, error) { fake.getRouterGroupsMutex.Lock() ret, specificReturn := fake.getRouterGroupsReturnsOnCall[len(fake.getRouterGroupsArgsForCall)] - fake.getRouterGroupsArgsForCall = append(fake.getRouterGroupsArgsForCall, struct { - }{}) + fake.getRouterGroupsArgsForCall = append(fake.getRouterGroupsArgsForCall, struct{}{}) stub := fake.GetRouterGroupsStub fakeReturns := fake.getRouterGroupsReturns fake.recordInvocation("GetRouterGroups", []interface{}{}) @@ -12449,10 +14054,7 @@ func (fake *FakeActor) GetRouterGroupsReturnsOnCall(i int, result1 []v7action.Ro func (fake *FakeActor) GetRoutesByOrg(arg1 string, arg2 string) ([]resources.Route, v7action.Warnings, error) { fake.getRoutesByOrgMutex.Lock() ret, specificReturn := fake.getRoutesByOrgReturnsOnCall[len(fake.getRoutesByOrgArgsForCall)] - fake.getRoutesByOrgArgsForCall = append(fake.getRoutesByOrgArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRoutesByOrgArgsForCall = append(fake.getRoutesByOrgArgsForCall, FakeActorGetRoutesByOrgArgs{arg1, arg2}) stub := fake.GetRoutesByOrgStub fakeReturns := fake.getRoutesByOrgReturns fake.recordInvocation("GetRoutesByOrg", []interface{}{arg1, arg2}) @@ -12482,7 +14084,15 @@ func (fake *FakeActor) GetRoutesByOrgArgsForCall(i int) (string, string) { fake.getRoutesByOrgMutex.RLock() defer fake.getRoutesByOrgMutex.RUnlock() argsForCall := fake.getRoutesByOrgArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRoutesByOrgArgs() []FakeActorGetRoutesByOrgArgs { + fake.getRoutesByOrgMutex.RLock() + defer fake.getRoutesByOrgMutex.RUnlock() + args := make([]FakeActorGetRoutesByOrgArgs, len(fake.getRoutesByOrgArgsForCall)) + copy(args, fake.getRoutesByOrgArgsForCall) + return args } func (fake *FakeActor) GetRoutesByOrgReturns(result1 []resources.Route, result2 v7action.Warnings, result3 error) { @@ -12517,10 +14127,7 @@ func (fake *FakeActor) GetRoutesByOrgReturnsOnCall(i int, result1 []resources.Ro func (fake *FakeActor) GetRoutesBySpace(arg1 string, arg2 string) ([]resources.Route, v7action.Warnings, error) { fake.getRoutesBySpaceMutex.Lock() ret, specificReturn := fake.getRoutesBySpaceReturnsOnCall[len(fake.getRoutesBySpaceArgsForCall)] - fake.getRoutesBySpaceArgsForCall = append(fake.getRoutesBySpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getRoutesBySpaceArgsForCall = append(fake.getRoutesBySpaceArgsForCall, FakeActorGetRoutesBySpaceArgs{arg1, arg2}) stub := fake.GetRoutesBySpaceStub fakeReturns := fake.getRoutesBySpaceReturns fake.recordInvocation("GetRoutesBySpace", []interface{}{arg1, arg2}) @@ -12550,7 +14157,15 @@ func (fake *FakeActor) GetRoutesBySpaceArgsForCall(i int) (string, string) { fake.getRoutesBySpaceMutex.RLock() defer fake.getRoutesBySpaceMutex.RUnlock() argsForCall := fake.getRoutesBySpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetRoutesBySpaceArgs() []FakeActorGetRoutesBySpaceArgs { + fake.getRoutesBySpaceMutex.RLock() + defer fake.getRoutesBySpaceMutex.RUnlock() + args := make([]FakeActorGetRoutesBySpaceArgs, len(fake.getRoutesBySpaceArgsForCall)) + copy(args, fake.getRoutesBySpaceArgsForCall) + return args } func (fake *FakeActor) GetRoutesBySpaceReturns(result1 []resources.Route, result2 v7action.Warnings, result3 error) { @@ -12585,9 +14200,7 @@ func (fake *FakeActor) GetRoutesBySpaceReturnsOnCall(i int, result1 []resources. func (fake *FakeActor) GetSSHEnabled(arg1 string) (ccv3.SSHEnabled, v7action.Warnings, error) { fake.getSSHEnabledMutex.Lock() ret, specificReturn := fake.getSSHEnabledReturnsOnCall[len(fake.getSSHEnabledArgsForCall)] - fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, FakeActorGetSSHEnabledArgs{arg1}) stub := fake.GetSSHEnabledStub fakeReturns := fake.getSSHEnabledReturns fake.recordInvocation("GetSSHEnabled", []interface{}{arg1}) @@ -12617,7 +14230,15 @@ func (fake *FakeActor) GetSSHEnabledArgsForCall(i int) string { fake.getSSHEnabledMutex.RLock() defer fake.getSSHEnabledMutex.RUnlock() argsForCall := fake.getSSHEnabledArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetSSHEnabledArgs() []FakeActorGetSSHEnabledArgs { + fake.getSSHEnabledMutex.RLock() + defer fake.getSSHEnabledMutex.RUnlock() + args := make([]FakeActorGetSSHEnabledArgs, len(fake.getSSHEnabledArgsForCall)) + copy(args, fake.getSSHEnabledArgsForCall) + return args } func (fake *FakeActor) GetSSHEnabledReturns(result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) { @@ -12652,10 +14273,7 @@ func (fake *FakeActor) GetSSHEnabledReturnsOnCall(i int, result1 ccv3.SSHEnabled func (fake *FakeActor) GetSSHEnabledByAppName(arg1 string, arg2 string) (ccv3.SSHEnabled, v7action.Warnings, error) { fake.getSSHEnabledByAppNameMutex.Lock() ret, specificReturn := fake.getSSHEnabledByAppNameReturnsOnCall[len(fake.getSSHEnabledByAppNameArgsForCall)] - fake.getSSHEnabledByAppNameArgsForCall = append(fake.getSSHEnabledByAppNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSSHEnabledByAppNameArgsForCall = append(fake.getSSHEnabledByAppNameArgsForCall, FakeActorGetSSHEnabledByAppNameArgs{arg1, arg2}) stub := fake.GetSSHEnabledByAppNameStub fakeReturns := fake.getSSHEnabledByAppNameReturns fake.recordInvocation("GetSSHEnabledByAppName", []interface{}{arg1, arg2}) @@ -12685,7 +14303,15 @@ func (fake *FakeActor) GetSSHEnabledByAppNameArgsForCall(i int) (string, string) fake.getSSHEnabledByAppNameMutex.RLock() defer fake.getSSHEnabledByAppNameMutex.RUnlock() argsForCall := fake.getSSHEnabledByAppNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetSSHEnabledByAppNameArgs() []FakeActorGetSSHEnabledByAppNameArgs { + fake.getSSHEnabledByAppNameMutex.RLock() + defer fake.getSSHEnabledByAppNameMutex.RUnlock() + args := make([]FakeActorGetSSHEnabledByAppNameArgs, len(fake.getSSHEnabledByAppNameArgsForCall)) + copy(args, fake.getSSHEnabledByAppNameArgsForCall) + return args } func (fake *FakeActor) GetSSHEnabledByAppNameReturns(result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) { @@ -12720,8 +14346,7 @@ func (fake *FakeActor) GetSSHEnabledByAppNameReturnsOnCall(i int, result1 ccv3.S func (fake *FakeActor) GetSSHPasscode() (string, error) { fake.getSSHPasscodeMutex.Lock() ret, specificReturn := fake.getSSHPasscodeReturnsOnCall[len(fake.getSSHPasscodeArgsForCall)] - fake.getSSHPasscodeArgsForCall = append(fake.getSSHPasscodeArgsForCall, struct { - }{}) + fake.getSSHPasscodeArgsForCall = append(fake.getSSHPasscodeArgsForCall, struct{}{}) stub := fake.GetSSHPasscodeStub fakeReturns := fake.getSSHPasscodeReturns fake.recordInvocation("GetSSHPasscode", []interface{}{}) @@ -12776,12 +14401,7 @@ func (fake *FakeActor) GetSSHPasscodeReturnsOnCall(i int, result1 string, result func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex(arg1 string, arg2 string, arg3 string, arg4 uint) (v7action.SSHAuthentication, v7action.Warnings, error) { fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Lock() ret, specificReturn := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[len(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall)] - fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 uint - }{arg1, arg2, arg3, arg4}) + fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall, FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs{arg1, arg2, arg3, arg4}) stub := fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub fakeReturns := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns fake.recordInvocation("GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4}) @@ -12811,7 +14431,15 @@ func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessT fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RLock() defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock() argsForCall := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs() []FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs { + fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RLock() + defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock() + args := make([]FakeActorGetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgs, len(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall)) + copy(args, fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall) + return args } func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns(result1 v7action.SSHAuthentication, result2 v7action.Warnings, result3 error) { @@ -12846,9 +14474,7 @@ func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessT func (fake *FakeActor) GetSecurityGroup(arg1 string) (resources.SecurityGroup, v7action.Warnings, error) { fake.getSecurityGroupMutex.Lock() ret, specificReturn := fake.getSecurityGroupReturnsOnCall[len(fake.getSecurityGroupArgsForCall)] - fake.getSecurityGroupArgsForCall = append(fake.getSecurityGroupArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSecurityGroupArgsForCall = append(fake.getSecurityGroupArgsForCall, FakeActorGetSecurityGroupArgs{arg1}) stub := fake.GetSecurityGroupStub fakeReturns := fake.getSecurityGroupReturns fake.recordInvocation("GetSecurityGroup", []interface{}{arg1}) @@ -12878,7 +14504,15 @@ func (fake *FakeActor) GetSecurityGroupArgsForCall(i int) string { fake.getSecurityGroupMutex.RLock() defer fake.getSecurityGroupMutex.RUnlock() argsForCall := fake.getSecurityGroupArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetSecurityGroupArgs() []FakeActorGetSecurityGroupArgs { + fake.getSecurityGroupMutex.RLock() + defer fake.getSecurityGroupMutex.RUnlock() + args := make([]FakeActorGetSecurityGroupArgs, len(fake.getSecurityGroupArgsForCall)) + copy(args, fake.getSecurityGroupArgsForCall) + return args } func (fake *FakeActor) GetSecurityGroupReturns(result1 resources.SecurityGroup, result2 v7action.Warnings, result3 error) { @@ -12913,9 +14547,7 @@ func (fake *FakeActor) GetSecurityGroupReturnsOnCall(i int, result1 resources.Se func (fake *FakeActor) GetSecurityGroupSummary(arg1 string) (v7action.SecurityGroupSummary, v7action.Warnings, error) { fake.getSecurityGroupSummaryMutex.Lock() ret, specificReturn := fake.getSecurityGroupSummaryReturnsOnCall[len(fake.getSecurityGroupSummaryArgsForCall)] - fake.getSecurityGroupSummaryArgsForCall = append(fake.getSecurityGroupSummaryArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSecurityGroupSummaryArgsForCall = append(fake.getSecurityGroupSummaryArgsForCall, FakeActorGetSecurityGroupSummaryArgs{arg1}) stub := fake.GetSecurityGroupSummaryStub fakeReturns := fake.getSecurityGroupSummaryReturns fake.recordInvocation("GetSecurityGroupSummary", []interface{}{arg1}) @@ -12945,7 +14577,15 @@ func (fake *FakeActor) GetSecurityGroupSummaryArgsForCall(i int) string { fake.getSecurityGroupSummaryMutex.RLock() defer fake.getSecurityGroupSummaryMutex.RUnlock() argsForCall := fake.getSecurityGroupSummaryArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetSecurityGroupSummaryArgs() []FakeActorGetSecurityGroupSummaryArgs { + fake.getSecurityGroupSummaryMutex.RLock() + defer fake.getSecurityGroupSummaryMutex.RUnlock() + args := make([]FakeActorGetSecurityGroupSummaryArgs, len(fake.getSecurityGroupSummaryArgsForCall)) + copy(args, fake.getSecurityGroupSummaryArgsForCall) + return args } func (fake *FakeActor) GetSecurityGroupSummaryReturns(result1 v7action.SecurityGroupSummary, result2 v7action.Warnings, result3 error) { @@ -12980,8 +14620,7 @@ func (fake *FakeActor) GetSecurityGroupSummaryReturnsOnCall(i int, result1 v7act func (fake *FakeActor) GetSecurityGroups() ([]v7action.SecurityGroupSummary, v7action.Warnings, error) { fake.getSecurityGroupsMutex.Lock() ret, specificReturn := fake.getSecurityGroupsReturnsOnCall[len(fake.getSecurityGroupsArgsForCall)] - fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct { - }{}) + fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct{}{}) stub := fake.GetSecurityGroupsStub fakeReturns := fake.getSecurityGroupsReturns fake.recordInvocation("GetSecurityGroups", []interface{}{}) @@ -13039,11 +14678,7 @@ func (fake *FakeActor) GetSecurityGroupsReturnsOnCall(i int, result1 []v7action. func (fake *FakeActor) GetServiceAccess(arg1 string, arg2 string, arg3 string) ([]v7action.ServicePlanAccess, v7action.Warnings, error) { fake.getServiceAccessMutex.Lock() ret, specificReturn := fake.getServiceAccessReturnsOnCall[len(fake.getServiceAccessArgsForCall)] - fake.getServiceAccessArgsForCall = append(fake.getServiceAccessArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getServiceAccessArgsForCall = append(fake.getServiceAccessArgsForCall, FakeActorGetServiceAccessArgs{arg1, arg2, arg3}) stub := fake.GetServiceAccessStub fakeReturns := fake.getServiceAccessReturns fake.recordInvocation("GetServiceAccess", []interface{}{arg1, arg2, arg3}) @@ -13073,7 +14708,15 @@ func (fake *FakeActor) GetServiceAccessArgsForCall(i int) (string, string, strin fake.getServiceAccessMutex.RLock() defer fake.getServiceAccessMutex.RUnlock() argsForCall := fake.getServiceAccessArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServiceAccessArgs() []FakeActorGetServiceAccessArgs { + fake.getServiceAccessMutex.RLock() + defer fake.getServiceAccessMutex.RUnlock() + args := make([]FakeActorGetServiceAccessArgs, len(fake.getServiceAccessArgsForCall)) + copy(args, fake.getServiceAccessArgsForCall) + return args } func (fake *FakeActor) GetServiceAccessReturns(result1 []v7action.ServicePlanAccess, result2 v7action.Warnings, result3 error) { @@ -13105,12 +14748,156 @@ func (fake *FakeActor) GetServiceAccessReturnsOnCall(i int, result1 []v7action.S }{result1, result2, result3} } +func (fake *FakeActor) GetServiceAccountByNameAndSpace(arg1 string, arg2 string) (resources.ServiceAccount, v7action.Warnings, error) { + fake.getServiceAccountByNameAndSpaceMutex.Lock() + ret, specificReturn := fake.getServiceAccountByNameAndSpaceReturnsOnCall[len(fake.getServiceAccountByNameAndSpaceArgsForCall)] + fake.getServiceAccountByNameAndSpaceArgsForCall = append(fake.getServiceAccountByNameAndSpaceArgsForCall, FakeActorGetServiceAccountByNameAndSpaceArgs{arg1, arg2}) + stub := fake.GetServiceAccountByNameAndSpaceStub + fakeReturns := fake.getServiceAccountByNameAndSpaceReturns + fake.recordInvocation("GetServiceAccountByNameAndSpace", []interface{}{arg1, arg2}) + fake.getServiceAccountByNameAndSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceCallCount() int { + fake.getServiceAccountByNameAndSpaceMutex.RLock() + defer fake.getServiceAccountByNameAndSpaceMutex.RUnlock() + return len(fake.getServiceAccountByNameAndSpaceArgsForCall) +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceCalls(stub func(string, string) (resources.ServiceAccount, v7action.Warnings, error)) { + fake.getServiceAccountByNameAndSpaceMutex.Lock() + defer fake.getServiceAccountByNameAndSpaceMutex.Unlock() + fake.GetServiceAccountByNameAndSpaceStub = stub +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceArgsForCall(i int) (string, string) { + fake.getServiceAccountByNameAndSpaceMutex.RLock() + defer fake.getServiceAccountByNameAndSpaceMutex.RUnlock() + argsForCall := fake.getServiceAccountByNameAndSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceArgs() []FakeActorGetServiceAccountByNameAndSpaceArgs { + fake.getServiceAccountByNameAndSpaceMutex.RLock() + defer fake.getServiceAccountByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetServiceAccountByNameAndSpaceArgs, len(fake.getServiceAccountByNameAndSpaceArgsForCall)) + copy(args, fake.getServiceAccountByNameAndSpaceArgsForCall) + return args +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceReturns(result1 resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.getServiceAccountByNameAndSpaceMutex.Lock() + defer fake.getServiceAccountByNameAndSpaceMutex.Unlock() + fake.GetServiceAccountByNameAndSpaceStub = nil + fake.getServiceAccountByNameAndSpaceReturns = struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetServiceAccountByNameAndSpaceReturnsOnCall(i int, result1 resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.getServiceAccountByNameAndSpaceMutex.Lock() + defer fake.getServiceAccountByNameAndSpaceMutex.Unlock() + fake.GetServiceAccountByNameAndSpaceStub = nil + if fake.getServiceAccountByNameAndSpaceReturnsOnCall == nil { + fake.getServiceAccountByNameAndSpaceReturnsOnCall = make(map[int]struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }) + } + fake.getServiceAccountByNameAndSpaceReturnsOnCall[i] = struct { + result1 resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetServiceAccountsInSpace(arg1 string) ([]resources.ServiceAccount, v7action.Warnings, error) { + fake.getServiceAccountsInSpaceMutex.Lock() + ret, specificReturn := fake.getServiceAccountsInSpaceReturnsOnCall[len(fake.getServiceAccountsInSpaceArgsForCall)] + fake.getServiceAccountsInSpaceArgsForCall = append(fake.getServiceAccountsInSpaceArgsForCall, FakeActorGetServiceAccountsInSpaceArgs{arg1}) + stub := fake.GetServiceAccountsInSpaceStub + fakeReturns := fake.getServiceAccountsInSpaceReturns + fake.recordInvocation("GetServiceAccountsInSpace", []interface{}{arg1}) + fake.getServiceAccountsInSpaceMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeActor) GetServiceAccountsInSpaceCallCount() int { + fake.getServiceAccountsInSpaceMutex.RLock() + defer fake.getServiceAccountsInSpaceMutex.RUnlock() + return len(fake.getServiceAccountsInSpaceArgsForCall) +} + +func (fake *FakeActor) GetServiceAccountsInSpaceCalls(stub func(string) ([]resources.ServiceAccount, v7action.Warnings, error)) { + fake.getServiceAccountsInSpaceMutex.Lock() + defer fake.getServiceAccountsInSpaceMutex.Unlock() + fake.GetServiceAccountsInSpaceStub = stub +} + +func (fake *FakeActor) GetServiceAccountsInSpaceArgsForCall(i int) string { + fake.getServiceAccountsInSpaceMutex.RLock() + defer fake.getServiceAccountsInSpaceMutex.RUnlock() + argsForCall := fake.getServiceAccountsInSpaceArgsForCall[i] + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetServiceAccountsInSpaceArgs() []FakeActorGetServiceAccountsInSpaceArgs { + fake.getServiceAccountsInSpaceMutex.RLock() + defer fake.getServiceAccountsInSpaceMutex.RUnlock() + args := make([]FakeActorGetServiceAccountsInSpaceArgs, len(fake.getServiceAccountsInSpaceArgsForCall)) + copy(args, fake.getServiceAccountsInSpaceArgsForCall) + return args +} + +func (fake *FakeActor) GetServiceAccountsInSpaceReturns(result1 []resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.getServiceAccountsInSpaceMutex.Lock() + defer fake.getServiceAccountsInSpaceMutex.Unlock() + fake.GetServiceAccountsInSpaceStub = nil + fake.getServiceAccountsInSpaceReturns = struct { + result1 []resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetServiceAccountsInSpaceReturnsOnCall(i int, result1 []resources.ServiceAccount, result2 v7action.Warnings, result3 error) { + fake.getServiceAccountsInSpaceMutex.Lock() + defer fake.getServiceAccountsInSpaceMutex.Unlock() + fake.GetServiceAccountsInSpaceStub = nil + if fake.getServiceAccountsInSpaceReturnsOnCall == nil { + fake.getServiceAccountsInSpaceReturnsOnCall = make(map[int]struct { + result1 []resources.ServiceAccount + result2 v7action.Warnings + result3 error + }) + } + fake.getServiceAccountsInSpaceReturnsOnCall[i] = struct { + result1 []resources.ServiceAccount + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeActor) GetServiceBrokerByName(arg1 string) (resources.ServiceBroker, v7action.Warnings, error) { fake.getServiceBrokerByNameMutex.Lock() ret, specificReturn := fake.getServiceBrokerByNameReturnsOnCall[len(fake.getServiceBrokerByNameArgsForCall)] - fake.getServiceBrokerByNameArgsForCall = append(fake.getServiceBrokerByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceBrokerByNameArgsForCall = append(fake.getServiceBrokerByNameArgsForCall, FakeActorGetServiceBrokerByNameArgs{arg1}) stub := fake.GetServiceBrokerByNameStub fakeReturns := fake.getServiceBrokerByNameReturns fake.recordInvocation("GetServiceBrokerByName", []interface{}{arg1}) @@ -13140,7 +14927,15 @@ func (fake *FakeActor) GetServiceBrokerByNameArgsForCall(i int) string { fake.getServiceBrokerByNameMutex.RLock() defer fake.getServiceBrokerByNameMutex.RUnlock() argsForCall := fake.getServiceBrokerByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetServiceBrokerByNameArgs() []FakeActorGetServiceBrokerByNameArgs { + fake.getServiceBrokerByNameMutex.RLock() + defer fake.getServiceBrokerByNameMutex.RUnlock() + args := make([]FakeActorGetServiceBrokerByNameArgs, len(fake.getServiceBrokerByNameArgsForCall)) + copy(args, fake.getServiceBrokerByNameArgsForCall) + return args } func (fake *FakeActor) GetServiceBrokerByNameReturns(result1 resources.ServiceBroker, result2 v7action.Warnings, result3 error) { @@ -13175,9 +14970,7 @@ func (fake *FakeActor) GetServiceBrokerByNameReturnsOnCall(i int, result1 resour func (fake *FakeActor) GetServiceBrokerLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getServiceBrokerLabelsMutex.Lock() ret, specificReturn := fake.getServiceBrokerLabelsReturnsOnCall[len(fake.getServiceBrokerLabelsArgsForCall)] - fake.getServiceBrokerLabelsArgsForCall = append(fake.getServiceBrokerLabelsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceBrokerLabelsArgsForCall = append(fake.getServiceBrokerLabelsArgsForCall, FakeActorGetServiceBrokerLabelsArgs{arg1}) stub := fake.GetServiceBrokerLabelsStub fakeReturns := fake.getServiceBrokerLabelsReturns fake.recordInvocation("GetServiceBrokerLabels", []interface{}{arg1}) @@ -13207,7 +15000,15 @@ func (fake *FakeActor) GetServiceBrokerLabelsArgsForCall(i int) string { fake.getServiceBrokerLabelsMutex.RLock() defer fake.getServiceBrokerLabelsMutex.RUnlock() argsForCall := fake.getServiceBrokerLabelsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetServiceBrokerLabelsArgs() []FakeActorGetServiceBrokerLabelsArgs { + fake.getServiceBrokerLabelsMutex.RLock() + defer fake.getServiceBrokerLabelsMutex.RUnlock() + args := make([]FakeActorGetServiceBrokerLabelsArgs, len(fake.getServiceBrokerLabelsArgsForCall)) + copy(args, fake.getServiceBrokerLabelsArgsForCall) + return args } func (fake *FakeActor) GetServiceBrokerLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -13242,8 +15043,7 @@ func (fake *FakeActor) GetServiceBrokerLabelsReturnsOnCall(i int, result1 map[st func (fake *FakeActor) GetServiceBrokers() ([]resources.ServiceBroker, v7action.Warnings, error) { fake.getServiceBrokersMutex.Lock() ret, specificReturn := fake.getServiceBrokersReturnsOnCall[len(fake.getServiceBrokersArgsForCall)] - fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, struct { - }{}) + fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, struct{}{}) stub := fake.GetServiceBrokersStub fakeReturns := fake.getServiceBrokersReturns fake.recordInvocation("GetServiceBrokers", []interface{}{}) @@ -13301,9 +15101,7 @@ func (fake *FakeActor) GetServiceBrokersReturnsOnCall(i int, result1 []resources func (fake *FakeActor) GetServiceInstanceByGUID(arg1 string) (resources.ServiceInstance, v7action.Warnings, error) { fake.getServiceInstanceByGUIDMutex.Lock() ret, specificReturn := fake.getServiceInstanceByGUIDReturnsOnCall[len(fake.getServiceInstanceByGUIDArgsForCall)] - fake.getServiceInstanceByGUIDArgsForCall = append(fake.getServiceInstanceByGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getServiceInstanceByGUIDArgsForCall = append(fake.getServiceInstanceByGUIDArgsForCall, FakeActorGetServiceInstanceByGUIDArgs{arg1}) stub := fake.GetServiceInstanceByGUIDStub fakeReturns := fake.getServiceInstanceByGUIDReturns fake.recordInvocation("GetServiceInstanceByGUID", []interface{}{arg1}) @@ -13333,7 +15131,15 @@ func (fake *FakeActor) GetServiceInstanceByGUIDArgsForCall(i int) string { fake.getServiceInstanceByGUIDMutex.RLock() defer fake.getServiceInstanceByGUIDMutex.RUnlock() argsForCall := fake.getServiceInstanceByGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetServiceInstanceByGUIDArgs() []FakeActorGetServiceInstanceByGUIDArgs { + fake.getServiceInstanceByGUIDMutex.RLock() + defer fake.getServiceInstanceByGUIDMutex.RUnlock() + args := make([]FakeActorGetServiceInstanceByGUIDArgs, len(fake.getServiceInstanceByGUIDArgsForCall)) + copy(args, fake.getServiceInstanceByGUIDArgsForCall) + return args } func (fake *FakeActor) GetServiceInstanceByGUIDReturns(result1 resources.ServiceInstance, result2 v7action.Warnings, result3 error) { @@ -13368,10 +15174,7 @@ func (fake *FakeActor) GetServiceInstanceByGUIDReturnsOnCall(i int, result1 reso func (fake *FakeActor) GetServiceInstanceByNameAndSpace(arg1 string, arg2 string) (resources.ServiceInstance, v7action.Warnings, error) { fake.getServiceInstanceByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getServiceInstanceByNameAndSpaceReturnsOnCall[len(fake.getServiceInstanceByNameAndSpaceArgsForCall)] - fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, FakeActorGetServiceInstanceByNameAndSpaceArgs{arg1, arg2}) stub := fake.GetServiceInstanceByNameAndSpaceStub fakeReturns := fake.getServiceInstanceByNameAndSpaceReturns fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2}) @@ -13401,7 +15204,15 @@ func (fake *FakeActor) GetServiceInstanceByNameAndSpaceArgsForCall(i int) (strin fake.getServiceInstanceByNameAndSpaceMutex.RLock() defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock() argsForCall := fake.getServiceInstanceByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceInstanceByNameAndSpaceArgs() []FakeActorGetServiceInstanceByNameAndSpaceArgs { + fake.getServiceInstanceByNameAndSpaceMutex.RLock() + defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetServiceInstanceByNameAndSpaceArgs, len(fake.getServiceInstanceByNameAndSpaceArgsForCall)) + copy(args, fake.getServiceInstanceByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetServiceInstanceByNameAndSpaceReturns(result1 resources.ServiceInstance, result2 v7action.Warnings, result3 error) { @@ -13436,11 +15247,7 @@ func (fake *FakeActor) GetServiceInstanceByNameAndSpaceReturnsOnCall(i int, resu func (fake *FakeActor) GetServiceInstanceDetails(arg1 string, arg2 string, arg3 bool) (v7action.ServiceInstanceDetails, v7action.Warnings, error) { fake.getServiceInstanceDetailsMutex.Lock() ret, specificReturn := fake.getServiceInstanceDetailsReturnsOnCall[len(fake.getServiceInstanceDetailsArgsForCall)] - fake.getServiceInstanceDetailsArgsForCall = append(fake.getServiceInstanceDetailsArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - }{arg1, arg2, arg3}) + fake.getServiceInstanceDetailsArgsForCall = append(fake.getServiceInstanceDetailsArgsForCall, FakeActorGetServiceInstanceDetailsArgs{arg1, arg2, arg3}) stub := fake.GetServiceInstanceDetailsStub fakeReturns := fake.getServiceInstanceDetailsReturns fake.recordInvocation("GetServiceInstanceDetails", []interface{}{arg1, arg2, arg3}) @@ -13470,7 +15277,15 @@ func (fake *FakeActor) GetServiceInstanceDetailsArgsForCall(i int) (string, stri fake.getServiceInstanceDetailsMutex.RLock() defer fake.getServiceInstanceDetailsMutex.RUnlock() argsForCall := fake.getServiceInstanceDetailsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServiceInstanceDetailsArgs() []FakeActorGetServiceInstanceDetailsArgs { + fake.getServiceInstanceDetailsMutex.RLock() + defer fake.getServiceInstanceDetailsMutex.RUnlock() + args := make([]FakeActorGetServiceInstanceDetailsArgs, len(fake.getServiceInstanceDetailsArgsForCall)) + copy(args, fake.getServiceInstanceDetailsArgsForCall) + return args } func (fake *FakeActor) GetServiceInstanceDetailsReturns(result1 v7action.ServiceInstanceDetails, result2 v7action.Warnings, result3 error) { @@ -13505,10 +15320,7 @@ func (fake *FakeActor) GetServiceInstanceDetailsReturnsOnCall(i int, result1 v7a func (fake *FakeActor) GetServiceInstanceLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getServiceInstanceLabelsMutex.Lock() ret, specificReturn := fake.getServiceInstanceLabelsReturnsOnCall[len(fake.getServiceInstanceLabelsArgsForCall)] - fake.getServiceInstanceLabelsArgsForCall = append(fake.getServiceInstanceLabelsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceInstanceLabelsArgsForCall = append(fake.getServiceInstanceLabelsArgsForCall, FakeActorGetServiceInstanceLabelsArgs{arg1, arg2}) stub := fake.GetServiceInstanceLabelsStub fakeReturns := fake.getServiceInstanceLabelsReturns fake.recordInvocation("GetServiceInstanceLabels", []interface{}{arg1, arg2}) @@ -13538,7 +15350,15 @@ func (fake *FakeActor) GetServiceInstanceLabelsArgsForCall(i int) (string, strin fake.getServiceInstanceLabelsMutex.RLock() defer fake.getServiceInstanceLabelsMutex.RUnlock() argsForCall := fake.getServiceInstanceLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceInstanceLabelsArgs() []FakeActorGetServiceInstanceLabelsArgs { + fake.getServiceInstanceLabelsMutex.RLock() + defer fake.getServiceInstanceLabelsMutex.RUnlock() + args := make([]FakeActorGetServiceInstanceLabelsArgs, len(fake.getServiceInstanceLabelsArgsForCall)) + copy(args, fake.getServiceInstanceLabelsArgsForCall) + return args } func (fake *FakeActor) GetServiceInstanceLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -13573,10 +15393,7 @@ func (fake *FakeActor) GetServiceInstanceLabelsReturnsOnCall(i int, result1 map[ func (fake *FakeActor) GetServiceInstanceParameters(arg1 string, arg2 string) (v7action.ServiceInstanceParameters, v7action.Warnings, error) { fake.getServiceInstanceParametersMutex.Lock() ret, specificReturn := fake.getServiceInstanceParametersReturnsOnCall[len(fake.getServiceInstanceParametersArgsForCall)] - fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, FakeActorGetServiceInstanceParametersArgs{arg1, arg2}) stub := fake.GetServiceInstanceParametersStub fakeReturns := fake.getServiceInstanceParametersReturns fake.recordInvocation("GetServiceInstanceParameters", []interface{}{arg1, arg2}) @@ -13606,7 +15423,15 @@ func (fake *FakeActor) GetServiceInstanceParametersArgsForCall(i int) (string, s fake.getServiceInstanceParametersMutex.RLock() defer fake.getServiceInstanceParametersMutex.RUnlock() argsForCall := fake.getServiceInstanceParametersArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceInstanceParametersArgs() []FakeActorGetServiceInstanceParametersArgs { + fake.getServiceInstanceParametersMutex.RLock() + defer fake.getServiceInstanceParametersMutex.RUnlock() + args := make([]FakeActorGetServiceInstanceParametersArgs, len(fake.getServiceInstanceParametersArgsForCall)) + copy(args, fake.getServiceInstanceParametersArgsForCall) + return args } func (fake *FakeActor) GetServiceInstanceParametersReturns(result1 v7action.ServiceInstanceParameters, result2 v7action.Warnings, result3 error) { @@ -13641,10 +15466,7 @@ func (fake *FakeActor) GetServiceInstanceParametersReturnsOnCall(i int, result1 func (fake *FakeActor) GetServiceInstancesForSpace(arg1 string, arg2 bool) ([]v7action.ServiceInstance, v7action.Warnings, error) { fake.getServiceInstancesForSpaceMutex.Lock() ret, specificReturn := fake.getServiceInstancesForSpaceReturnsOnCall[len(fake.getServiceInstancesForSpaceArgsForCall)] - fake.getServiceInstancesForSpaceArgsForCall = append(fake.getServiceInstancesForSpaceArgsForCall, struct { - arg1 string - arg2 bool - }{arg1, arg2}) + fake.getServiceInstancesForSpaceArgsForCall = append(fake.getServiceInstancesForSpaceArgsForCall, FakeActorGetServiceInstancesForSpaceArgs{arg1, arg2}) stub := fake.GetServiceInstancesForSpaceStub fakeReturns := fake.getServiceInstancesForSpaceReturns fake.recordInvocation("GetServiceInstancesForSpace", []interface{}{arg1, arg2}) @@ -13674,7 +15496,15 @@ func (fake *FakeActor) GetServiceInstancesForSpaceArgsForCall(i int) (string, bo fake.getServiceInstancesForSpaceMutex.RLock() defer fake.getServiceInstancesForSpaceMutex.RUnlock() argsForCall := fake.getServiceInstancesForSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceInstancesForSpaceArgs() []FakeActorGetServiceInstancesForSpaceArgs { + fake.getServiceInstancesForSpaceMutex.RLock() + defer fake.getServiceInstancesForSpaceMutex.RUnlock() + args := make([]FakeActorGetServiceInstancesForSpaceArgs, len(fake.getServiceInstancesForSpaceArgsForCall)) + copy(args, fake.getServiceInstancesForSpaceArgsForCall) + return args } func (fake *FakeActor) GetServiceInstancesForSpaceReturns(result1 []v7action.ServiceInstance, result2 v7action.Warnings, result3 error) { @@ -13709,11 +15539,7 @@ func (fake *FakeActor) GetServiceInstancesForSpaceReturnsOnCall(i int, result1 [ func (fake *FakeActor) GetServiceKeyByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (resources.ServiceCredentialBinding, v7action.Warnings, error) { fake.getServiceKeyByServiceInstanceAndNameMutex.Lock() ret, specificReturn := fake.getServiceKeyByServiceInstanceAndNameReturnsOnCall[len(fake.getServiceKeyByServiceInstanceAndNameArgsForCall)] - fake.getServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyByServiceInstanceAndNameArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyByServiceInstanceAndNameArgsForCall, FakeActorGetServiceKeyByServiceInstanceAndNameArgs{arg1, arg2, arg3}) stub := fake.GetServiceKeyByServiceInstanceAndNameStub fakeReturns := fake.getServiceKeyByServiceInstanceAndNameReturns fake.recordInvocation("GetServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3}) @@ -13743,7 +15569,15 @@ func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameArgsForCall(i int) ( fake.getServiceKeyByServiceInstanceAndNameMutex.RLock() defer fake.getServiceKeyByServiceInstanceAndNameMutex.RUnlock() argsForCall := fake.getServiceKeyByServiceInstanceAndNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameArgs() []FakeActorGetServiceKeyByServiceInstanceAndNameArgs { + fake.getServiceKeyByServiceInstanceAndNameMutex.RLock() + defer fake.getServiceKeyByServiceInstanceAndNameMutex.RUnlock() + args := make([]FakeActorGetServiceKeyByServiceInstanceAndNameArgs, len(fake.getServiceKeyByServiceInstanceAndNameArgsForCall)) + copy(args, fake.getServiceKeyByServiceInstanceAndNameArgsForCall) + return args } func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameReturns(result1 resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) { @@ -13778,11 +15612,7 @@ func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameReturnsOnCall(i int, func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (resources.ServiceCredentialBindingDetails, v7action.Warnings, error) { fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Lock() ret, specificReturn := fake.getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall[len(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall)] - fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall, FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs{arg1, arg2, arg3}) stub := fake.GetServiceKeyDetailsByServiceInstanceAndNameStub fakeReturns := fake.getServiceKeyDetailsByServiceInstanceAndNameReturns fake.recordInvocation("GetServiceKeyDetailsByServiceInstanceAndName", []interface{}{arg1, arg2, arg3}) @@ -13812,7 +15642,15 @@ func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameArgsForCall(i fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RLock() defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RUnlock() argsForCall := fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameArgs() []FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs { + fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RLock() + defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RUnlock() + args := make([]FakeActorGetServiceKeyDetailsByServiceInstanceAndNameArgs, len(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall)) + copy(args, fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall) + return args } func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameReturns(result1 resources.ServiceCredentialBindingDetails, result2 v7action.Warnings, result3 error) { @@ -13847,10 +15685,7 @@ func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall func (fake *FakeActor) GetServiceKeysByServiceInstance(arg1 string, arg2 string) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) { fake.getServiceKeysByServiceInstanceMutex.Lock() ret, specificReturn := fake.getServiceKeysByServiceInstanceReturnsOnCall[len(fake.getServiceKeysByServiceInstanceArgsForCall)] - fake.getServiceKeysByServiceInstanceArgsForCall = append(fake.getServiceKeysByServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceKeysByServiceInstanceArgsForCall = append(fake.getServiceKeysByServiceInstanceArgsForCall, FakeActorGetServiceKeysByServiceInstanceArgs{arg1, arg2}) stub := fake.GetServiceKeysByServiceInstanceStub fakeReturns := fake.getServiceKeysByServiceInstanceReturns fake.recordInvocation("GetServiceKeysByServiceInstance", []interface{}{arg1, arg2}) @@ -13880,7 +15715,15 @@ func (fake *FakeActor) GetServiceKeysByServiceInstanceArgsForCall(i int) (string fake.getServiceKeysByServiceInstanceMutex.RLock() defer fake.getServiceKeysByServiceInstanceMutex.RUnlock() argsForCall := fake.getServiceKeysByServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceKeysByServiceInstanceArgs() []FakeActorGetServiceKeysByServiceInstanceArgs { + fake.getServiceKeysByServiceInstanceMutex.RLock() + defer fake.getServiceKeysByServiceInstanceMutex.RUnlock() + args := make([]FakeActorGetServiceKeysByServiceInstanceArgs, len(fake.getServiceKeysByServiceInstanceArgsForCall)) + copy(args, fake.getServiceKeysByServiceInstanceArgsForCall) + return args } func (fake *FakeActor) GetServiceKeysByServiceInstanceReturns(result1 []resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) { @@ -13915,10 +15758,7 @@ func (fake *FakeActor) GetServiceKeysByServiceInstanceReturnsOnCall(i int, resul func (fake *FakeActor) GetServiceOfferingLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getServiceOfferingLabelsMutex.Lock() ret, specificReturn := fake.getServiceOfferingLabelsReturnsOnCall[len(fake.getServiceOfferingLabelsArgsForCall)] - fake.getServiceOfferingLabelsArgsForCall = append(fake.getServiceOfferingLabelsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getServiceOfferingLabelsArgsForCall = append(fake.getServiceOfferingLabelsArgsForCall, FakeActorGetServiceOfferingLabelsArgs{arg1, arg2}) stub := fake.GetServiceOfferingLabelsStub fakeReturns := fake.getServiceOfferingLabelsReturns fake.recordInvocation("GetServiceOfferingLabels", []interface{}{arg1, arg2}) @@ -13944,11 +15784,19 @@ func (fake *FakeActor) GetServiceOfferingLabelsCalls(stub func(string, string) ( fake.GetServiceOfferingLabelsStub = stub } -func (fake *FakeActor) GetServiceOfferingLabelsArgsForCall(i int) (string, string) { +func (fake *FakeActor) GetServiceOfferingLabelsArgsForCall(i int) (string, string) { + fake.getServiceOfferingLabelsMutex.RLock() + defer fake.getServiceOfferingLabelsMutex.RUnlock() + argsForCall := fake.getServiceOfferingLabelsArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetServiceOfferingLabelsArgs() []FakeActorGetServiceOfferingLabelsArgs { fake.getServiceOfferingLabelsMutex.RLock() defer fake.getServiceOfferingLabelsMutex.RUnlock() - argsForCall := fake.getServiceOfferingLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + args := make([]FakeActorGetServiceOfferingLabelsArgs, len(fake.getServiceOfferingLabelsArgsForCall)) + copy(args, fake.getServiceOfferingLabelsArgsForCall) + return args } func (fake *FakeActor) GetServiceOfferingLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -13983,11 +15831,7 @@ func (fake *FakeActor) GetServiceOfferingLabelsReturnsOnCall(i int, result1 map[ func (fake *FakeActor) GetServicePlanByNameOfferingAndBroker(arg1 string, arg2 string, arg3 string) (resources.ServicePlan, v7action.Warnings, error) { fake.getServicePlanByNameOfferingAndBrokerMutex.Lock() ret, specificReturn := fake.getServicePlanByNameOfferingAndBrokerReturnsOnCall[len(fake.getServicePlanByNameOfferingAndBrokerArgsForCall)] - fake.getServicePlanByNameOfferingAndBrokerArgsForCall = append(fake.getServicePlanByNameOfferingAndBrokerArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getServicePlanByNameOfferingAndBrokerArgsForCall = append(fake.getServicePlanByNameOfferingAndBrokerArgsForCall, FakeActorGetServicePlanByNameOfferingAndBrokerArgs{arg1, arg2, arg3}) stub := fake.GetServicePlanByNameOfferingAndBrokerStub fakeReturns := fake.getServicePlanByNameOfferingAndBrokerReturns fake.recordInvocation("GetServicePlanByNameOfferingAndBroker", []interface{}{arg1, arg2, arg3}) @@ -14017,7 +15861,15 @@ func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerArgsForCall(i int) ( fake.getServicePlanByNameOfferingAndBrokerMutex.RLock() defer fake.getServicePlanByNameOfferingAndBrokerMutex.RUnlock() argsForCall := fake.getServicePlanByNameOfferingAndBrokerArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerArgs() []FakeActorGetServicePlanByNameOfferingAndBrokerArgs { + fake.getServicePlanByNameOfferingAndBrokerMutex.RLock() + defer fake.getServicePlanByNameOfferingAndBrokerMutex.RUnlock() + args := make([]FakeActorGetServicePlanByNameOfferingAndBrokerArgs, len(fake.getServicePlanByNameOfferingAndBrokerArgsForCall)) + copy(args, fake.getServicePlanByNameOfferingAndBrokerArgsForCall) + return args } func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerReturns(result1 resources.ServicePlan, result2 v7action.Warnings, result3 error) { @@ -14052,11 +15904,7 @@ func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerReturnsOnCall(i int, func (fake *FakeActor) GetServicePlanLabels(arg1 string, arg2 string, arg3 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getServicePlanLabelsMutex.Lock() ret, specificReturn := fake.getServicePlanLabelsReturnsOnCall[len(fake.getServicePlanLabelsArgsForCall)] - fake.getServicePlanLabelsArgsForCall = append(fake.getServicePlanLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getServicePlanLabelsArgsForCall = append(fake.getServicePlanLabelsArgsForCall, FakeActorGetServicePlanLabelsArgs{arg1, arg2, arg3}) stub := fake.GetServicePlanLabelsStub fakeReturns := fake.getServicePlanLabelsReturns fake.recordInvocation("GetServicePlanLabels", []interface{}{arg1, arg2, arg3}) @@ -14086,7 +15934,15 @@ func (fake *FakeActor) GetServicePlanLabelsArgsForCall(i int) (string, string, s fake.getServicePlanLabelsMutex.RLock() defer fake.getServicePlanLabelsMutex.RUnlock() argsForCall := fake.getServicePlanLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetServicePlanLabelsArgs() []FakeActorGetServicePlanLabelsArgs { + fake.getServicePlanLabelsMutex.RLock() + defer fake.getServicePlanLabelsMutex.RUnlock() + args := make([]FakeActorGetServicePlanLabelsArgs, len(fake.getServicePlanLabelsArgsForCall)) + copy(args, fake.getServicePlanLabelsArgsForCall) + return args } func (fake *FakeActor) GetServicePlanLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -14121,10 +15977,7 @@ func (fake *FakeActor) GetServicePlanLabelsReturnsOnCall(i int, result1 map[stri func (fake *FakeActor) GetSpaceByNameAndOrganization(arg1 string, arg2 string) (resources.Space, v7action.Warnings, error) { fake.getSpaceByNameAndOrganizationMutex.Lock() ret, specificReturn := fake.getSpaceByNameAndOrganizationReturnsOnCall[len(fake.getSpaceByNameAndOrganizationArgsForCall)] - fake.getSpaceByNameAndOrganizationArgsForCall = append(fake.getSpaceByNameAndOrganizationArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSpaceByNameAndOrganizationArgsForCall = append(fake.getSpaceByNameAndOrganizationArgsForCall, FakeActorGetSpaceByNameAndOrganizationArgs{arg1, arg2}) stub := fake.GetSpaceByNameAndOrganizationStub fakeReturns := fake.getSpaceByNameAndOrganizationReturns fake.recordInvocation("GetSpaceByNameAndOrganization", []interface{}{arg1, arg2}) @@ -14154,7 +16007,15 @@ func (fake *FakeActor) GetSpaceByNameAndOrganizationArgsForCall(i int) (string, fake.getSpaceByNameAndOrganizationMutex.RLock() defer fake.getSpaceByNameAndOrganizationMutex.RUnlock() argsForCall := fake.getSpaceByNameAndOrganizationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetSpaceByNameAndOrganizationArgs() []FakeActorGetSpaceByNameAndOrganizationArgs { + fake.getSpaceByNameAndOrganizationMutex.RLock() + defer fake.getSpaceByNameAndOrganizationMutex.RUnlock() + args := make([]FakeActorGetSpaceByNameAndOrganizationArgs, len(fake.getSpaceByNameAndOrganizationArgsForCall)) + copy(args, fake.getSpaceByNameAndOrganizationArgsForCall) + return args } func (fake *FakeActor) GetSpaceByNameAndOrganizationReturns(result1 resources.Space, result2 v7action.Warnings, result3 error) { @@ -14189,11 +16050,7 @@ func (fake *FakeActor) GetSpaceByNameAndOrganizationReturnsOnCall(i int, result1 func (fake *FakeActor) GetSpaceFeature(arg1 string, arg2 string, arg3 string) (bool, v7action.Warnings, error) { fake.getSpaceFeatureMutex.Lock() ret, specificReturn := fake.getSpaceFeatureReturnsOnCall[len(fake.getSpaceFeatureArgsForCall)] - fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, FakeActorGetSpaceFeatureArgs{arg1, arg2, arg3}) stub := fake.GetSpaceFeatureStub fakeReturns := fake.getSpaceFeatureReturns fake.recordInvocation("GetSpaceFeature", []interface{}{arg1, arg2, arg3}) @@ -14223,7 +16080,15 @@ func (fake *FakeActor) GetSpaceFeatureArgsForCall(i int) (string, string, string fake.getSpaceFeatureMutex.RLock() defer fake.getSpaceFeatureMutex.RUnlock() argsForCall := fake.getSpaceFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetSpaceFeatureArgs() []FakeActorGetSpaceFeatureArgs { + fake.getSpaceFeatureMutex.RLock() + defer fake.getSpaceFeatureMutex.RUnlock() + args := make([]FakeActorGetSpaceFeatureArgs, len(fake.getSpaceFeatureArgsForCall)) + copy(args, fake.getSpaceFeatureArgsForCall) + return args } func (fake *FakeActor) GetSpaceFeatureReturns(result1 bool, result2 v7action.Warnings, result3 error) { @@ -14258,10 +16123,7 @@ func (fake *FakeActor) GetSpaceFeatureReturnsOnCall(i int, result1 bool, result2 func (fake *FakeActor) GetSpaceLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getSpaceLabelsMutex.Lock() ret, specificReturn := fake.getSpaceLabelsReturnsOnCall[len(fake.getSpaceLabelsArgsForCall)] - fake.getSpaceLabelsArgsForCall = append(fake.getSpaceLabelsArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSpaceLabelsArgsForCall = append(fake.getSpaceLabelsArgsForCall, FakeActorGetSpaceLabelsArgs{arg1, arg2}) stub := fake.GetSpaceLabelsStub fakeReturns := fake.getSpaceLabelsReturns fake.recordInvocation("GetSpaceLabels", []interface{}{arg1, arg2}) @@ -14291,7 +16153,15 @@ func (fake *FakeActor) GetSpaceLabelsArgsForCall(i int) (string, string) { fake.getSpaceLabelsMutex.RLock() defer fake.getSpaceLabelsMutex.RUnlock() argsForCall := fake.getSpaceLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetSpaceLabelsArgs() []FakeActorGetSpaceLabelsArgs { + fake.getSpaceLabelsMutex.RLock() + defer fake.getSpaceLabelsMutex.RUnlock() + args := make([]FakeActorGetSpaceLabelsArgs, len(fake.getSpaceLabelsArgsForCall)) + copy(args, fake.getSpaceLabelsArgsForCall) + return args } func (fake *FakeActor) GetSpaceLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -14326,10 +16196,7 @@ func (fake *FakeActor) GetSpaceLabelsReturnsOnCall(i int, result1 map[string]typ func (fake *FakeActor) GetSpaceQuotaByName(arg1 string, arg2 string) (resources.SpaceQuota, v7action.Warnings, error) { fake.getSpaceQuotaByNameMutex.Lock() ret, specificReturn := fake.getSpaceQuotaByNameReturnsOnCall[len(fake.getSpaceQuotaByNameArgsForCall)] - fake.getSpaceQuotaByNameArgsForCall = append(fake.getSpaceQuotaByNameArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSpaceQuotaByNameArgsForCall = append(fake.getSpaceQuotaByNameArgsForCall, FakeActorGetSpaceQuotaByNameArgs{arg1, arg2}) stub := fake.GetSpaceQuotaByNameStub fakeReturns := fake.getSpaceQuotaByNameReturns fake.recordInvocation("GetSpaceQuotaByName", []interface{}{arg1, arg2}) @@ -14359,7 +16226,15 @@ func (fake *FakeActor) GetSpaceQuotaByNameArgsForCall(i int) (string, string) { fake.getSpaceQuotaByNameMutex.RLock() defer fake.getSpaceQuotaByNameMutex.RUnlock() argsForCall := fake.getSpaceQuotaByNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetSpaceQuotaByNameArgs() []FakeActorGetSpaceQuotaByNameArgs { + fake.getSpaceQuotaByNameMutex.RLock() + defer fake.getSpaceQuotaByNameMutex.RUnlock() + args := make([]FakeActorGetSpaceQuotaByNameArgs, len(fake.getSpaceQuotaByNameArgsForCall)) + copy(args, fake.getSpaceQuotaByNameArgsForCall) + return args } func (fake *FakeActor) GetSpaceQuotaByNameReturns(result1 resources.SpaceQuota, result2 v7action.Warnings, result3 error) { @@ -14394,9 +16269,7 @@ func (fake *FakeActor) GetSpaceQuotaByNameReturnsOnCall(i int, result1 resources func (fake *FakeActor) GetSpaceQuotasByOrgGUID(arg1 string) ([]resources.SpaceQuota, v7action.Warnings, error) { fake.getSpaceQuotasByOrgGUIDMutex.Lock() ret, specificReturn := fake.getSpaceQuotasByOrgGUIDReturnsOnCall[len(fake.getSpaceQuotasByOrgGUIDArgsForCall)] - fake.getSpaceQuotasByOrgGUIDArgsForCall = append(fake.getSpaceQuotasByOrgGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSpaceQuotasByOrgGUIDArgsForCall = append(fake.getSpaceQuotasByOrgGUIDArgsForCall, FakeActorGetSpaceQuotasByOrgGUIDArgs{arg1}) stub := fake.GetSpaceQuotasByOrgGUIDStub fakeReturns := fake.getSpaceQuotasByOrgGUIDReturns fake.recordInvocation("GetSpaceQuotasByOrgGUID", []interface{}{arg1}) @@ -14426,7 +16299,15 @@ func (fake *FakeActor) GetSpaceQuotasByOrgGUIDArgsForCall(i int) string { fake.getSpaceQuotasByOrgGUIDMutex.RLock() defer fake.getSpaceQuotasByOrgGUIDMutex.RUnlock() argsForCall := fake.getSpaceQuotasByOrgGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetSpaceQuotasByOrgGUIDArgs() []FakeActorGetSpaceQuotasByOrgGUIDArgs { + fake.getSpaceQuotasByOrgGUIDMutex.RLock() + defer fake.getSpaceQuotasByOrgGUIDMutex.RUnlock() + args := make([]FakeActorGetSpaceQuotasByOrgGUIDArgs, len(fake.getSpaceQuotasByOrgGUIDArgsForCall)) + copy(args, fake.getSpaceQuotasByOrgGUIDArgsForCall) + return args } func (fake *FakeActor) GetSpaceQuotasByOrgGUIDReturns(result1 []resources.SpaceQuota, result2 v7action.Warnings, result3 error) { @@ -14461,10 +16342,7 @@ func (fake *FakeActor) GetSpaceQuotasByOrgGUIDReturnsOnCall(i int, result1 []res func (fake *FakeActor) GetSpaceSummaryByNameAndOrganization(arg1 string, arg2 string) (v7action.SpaceSummary, v7action.Warnings, error) { fake.getSpaceSummaryByNameAndOrganizationMutex.Lock() ret, specificReturn := fake.getSpaceSummaryByNameAndOrganizationReturnsOnCall[len(fake.getSpaceSummaryByNameAndOrganizationArgsForCall)] - fake.getSpaceSummaryByNameAndOrganizationArgsForCall = append(fake.getSpaceSummaryByNameAndOrganizationArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getSpaceSummaryByNameAndOrganizationArgsForCall = append(fake.getSpaceSummaryByNameAndOrganizationArgsForCall, FakeActorGetSpaceSummaryByNameAndOrganizationArgs{arg1, arg2}) stub := fake.GetSpaceSummaryByNameAndOrganizationStub fakeReturns := fake.getSpaceSummaryByNameAndOrganizationReturns fake.recordInvocation("GetSpaceSummaryByNameAndOrganization", []interface{}{arg1, arg2}) @@ -14494,7 +16372,15 @@ func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationArgsForCall(i int) (s fake.getSpaceSummaryByNameAndOrganizationMutex.RLock() defer fake.getSpaceSummaryByNameAndOrganizationMutex.RUnlock() argsForCall := fake.getSpaceSummaryByNameAndOrganizationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationArgs() []FakeActorGetSpaceSummaryByNameAndOrganizationArgs { + fake.getSpaceSummaryByNameAndOrganizationMutex.RLock() + defer fake.getSpaceSummaryByNameAndOrganizationMutex.RUnlock() + args := make([]FakeActorGetSpaceSummaryByNameAndOrganizationArgs, len(fake.getSpaceSummaryByNameAndOrganizationArgsForCall)) + copy(args, fake.getSpaceSummaryByNameAndOrganizationArgsForCall) + return args } func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationReturns(result1 v7action.SpaceSummary, result2 v7action.Warnings, result3 error) { @@ -14529,9 +16415,7 @@ func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationReturnsOnCall(i int, func (fake *FakeActor) GetSpaceUsersByRoleType(arg1 string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) { fake.getSpaceUsersByRoleTypeMutex.Lock() ret, specificReturn := fake.getSpaceUsersByRoleTypeReturnsOnCall[len(fake.getSpaceUsersByRoleTypeArgsForCall)] - fake.getSpaceUsersByRoleTypeArgsForCall = append(fake.getSpaceUsersByRoleTypeArgsForCall, struct { - arg1 string - }{arg1}) + fake.getSpaceUsersByRoleTypeArgsForCall = append(fake.getSpaceUsersByRoleTypeArgsForCall, FakeActorGetSpaceUsersByRoleTypeArgs{arg1}) stub := fake.GetSpaceUsersByRoleTypeStub fakeReturns := fake.getSpaceUsersByRoleTypeReturns fake.recordInvocation("GetSpaceUsersByRoleType", []interface{}{arg1}) @@ -14561,7 +16445,15 @@ func (fake *FakeActor) GetSpaceUsersByRoleTypeArgsForCall(i int) string { fake.getSpaceUsersByRoleTypeMutex.RLock() defer fake.getSpaceUsersByRoleTypeMutex.RUnlock() argsForCall := fake.getSpaceUsersByRoleTypeArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetSpaceUsersByRoleTypeArgs() []FakeActorGetSpaceUsersByRoleTypeArgs { + fake.getSpaceUsersByRoleTypeMutex.RLock() + defer fake.getSpaceUsersByRoleTypeMutex.RUnlock() + args := make([]FakeActorGetSpaceUsersByRoleTypeArgs, len(fake.getSpaceUsersByRoleTypeArgsForCall)) + copy(args, fake.getSpaceUsersByRoleTypeArgsForCall) + return args } func (fake *FakeActor) GetSpaceUsersByRoleTypeReturns(result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) { @@ -14596,9 +16488,7 @@ func (fake *FakeActor) GetSpaceUsersByRoleTypeReturnsOnCall(i int, result1 map[c func (fake *FakeActor) GetStackByName(arg1 string) (resources.Stack, v7action.Warnings, error) { fake.getStackByNameMutex.Lock() ret, specificReturn := fake.getStackByNameReturnsOnCall[len(fake.getStackByNameArgsForCall)] - fake.getStackByNameArgsForCall = append(fake.getStackByNameArgsForCall, struct { - arg1 string - }{arg1}) + fake.getStackByNameArgsForCall = append(fake.getStackByNameArgsForCall, FakeActorGetStackByNameArgs{arg1}) stub := fake.GetStackByNameStub fakeReturns := fake.getStackByNameReturns fake.recordInvocation("GetStackByName", []interface{}{arg1}) @@ -14628,7 +16518,15 @@ func (fake *FakeActor) GetStackByNameArgsForCall(i int) string { fake.getStackByNameMutex.RLock() defer fake.getStackByNameMutex.RUnlock() argsForCall := fake.getStackByNameArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetStackByNameArgs() []FakeActorGetStackByNameArgs { + fake.getStackByNameMutex.RLock() + defer fake.getStackByNameMutex.RUnlock() + args := make([]FakeActorGetStackByNameArgs, len(fake.getStackByNameArgsForCall)) + copy(args, fake.getStackByNameArgsForCall) + return args } func (fake *FakeActor) GetStackByNameReturns(result1 resources.Stack, result2 v7action.Warnings, result3 error) { @@ -14663,9 +16561,7 @@ func (fake *FakeActor) GetStackByNameReturnsOnCall(i int, result1 resources.Stac func (fake *FakeActor) GetStackLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) { fake.getStackLabelsMutex.Lock() ret, specificReturn := fake.getStackLabelsReturnsOnCall[len(fake.getStackLabelsArgsForCall)] - fake.getStackLabelsArgsForCall = append(fake.getStackLabelsArgsForCall, struct { - arg1 string - }{arg1}) + fake.getStackLabelsArgsForCall = append(fake.getStackLabelsArgsForCall, FakeActorGetStackLabelsArgs{arg1}) stub := fake.GetStackLabelsStub fakeReturns := fake.getStackLabelsReturns fake.recordInvocation("GetStackLabels", []interface{}{arg1}) @@ -14695,7 +16591,15 @@ func (fake *FakeActor) GetStackLabelsArgsForCall(i int) string { fake.getStackLabelsMutex.RLock() defer fake.getStackLabelsMutex.RUnlock() argsForCall := fake.getStackLabelsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetStackLabelsArgs() []FakeActorGetStackLabelsArgs { + fake.getStackLabelsMutex.RLock() + defer fake.getStackLabelsMutex.RUnlock() + args := make([]FakeActorGetStackLabelsArgs, len(fake.getStackLabelsArgsForCall)) + copy(args, fake.getStackLabelsArgsForCall) + return args } func (fake *FakeActor) GetStackLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) { @@ -14730,9 +16634,7 @@ func (fake *FakeActor) GetStackLabelsReturnsOnCall(i int, result1 map[string]typ func (fake *FakeActor) GetStacks(arg1 string) ([]resources.Stack, v7action.Warnings, error) { fake.getStacksMutex.Lock() ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)] - fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct { - arg1 string - }{arg1}) + fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, FakeActorGetStacksArgs{arg1}) stub := fake.GetStacksStub fakeReturns := fake.getStacksReturns fake.recordInvocation("GetStacks", []interface{}{arg1}) @@ -14762,7 +16664,15 @@ func (fake *FakeActor) GetStacksArgsForCall(i int) string { fake.getStacksMutex.RLock() defer fake.getStacksMutex.RUnlock() argsForCall := fake.getStacksArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetStacksArgs() []FakeActorGetStacksArgs { + fake.getStacksMutex.RLock() + defer fake.getStacksMutex.RUnlock() + args := make([]FakeActorGetStacksArgs, len(fake.getStacksArgsForCall)) + copy(args, fake.getStacksArgsForCall) + return args } func (fake *FakeActor) GetStacksReturns(result1 []resources.Stack, result2 v7action.Warnings, result3 error) { @@ -14797,11 +16707,7 @@ func (fake *FakeActor) GetStacksReturnsOnCall(i int, result1 []resources.Stack, func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpace(arg1 string, arg2 string, arg3 sharedaction.LogCacheClient) (<-chan sharedaction.LogMessage, <-chan error, context.CancelFunc, v7action.Warnings, error) { fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall[len(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall)] - fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 sharedaction.LogCacheClient - }{arg1, arg2, arg3}) + fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall, FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.GetStreamingLogsForApplicationByNameAndSpaceStub fakeReturns := fake.getStreamingLogsForApplicationByNameAndSpaceReturns fake.recordInvocation("GetStreamingLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -14831,7 +16737,15 @@ func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceArgsForCall(i fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RLock() defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RUnlock() argsForCall := fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceArgs() []FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs { + fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RLock() + defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorGetStreamingLogsForApplicationByNameAndSpaceArgs, len(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall)) + copy(args, fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceReturns(result1 <-chan sharedaction.LogMessage, result2 <-chan error, result3 context.CancelFunc, result4 v7action.Warnings, result5 error) { @@ -14872,10 +16786,7 @@ func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceReturnsOnCall func (fake *FakeActor) GetTaskBySequenceIDAndApplication(arg1 int, arg2 string) (resources.Task, v7action.Warnings, error) { fake.getTaskBySequenceIDAndApplicationMutex.Lock() ret, specificReturn := fake.getTaskBySequenceIDAndApplicationReturnsOnCall[len(fake.getTaskBySequenceIDAndApplicationArgsForCall)] - fake.getTaskBySequenceIDAndApplicationArgsForCall = append(fake.getTaskBySequenceIDAndApplicationArgsForCall, struct { - arg1 int - arg2 string - }{arg1, arg2}) + fake.getTaskBySequenceIDAndApplicationArgsForCall = append(fake.getTaskBySequenceIDAndApplicationArgsForCall, FakeActorGetTaskBySequenceIDAndApplicationArgs{arg1, arg2}) stub := fake.GetTaskBySequenceIDAndApplicationStub fakeReturns := fake.getTaskBySequenceIDAndApplicationReturns fake.recordInvocation("GetTaskBySequenceIDAndApplication", []interface{}{arg1, arg2}) @@ -14905,7 +16816,15 @@ func (fake *FakeActor) GetTaskBySequenceIDAndApplicationArgsForCall(i int) (int, fake.getTaskBySequenceIDAndApplicationMutex.RLock() defer fake.getTaskBySequenceIDAndApplicationMutex.RUnlock() argsForCall := fake.getTaskBySequenceIDAndApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetTaskBySequenceIDAndApplicationArgs() []FakeActorGetTaskBySequenceIDAndApplicationArgs { + fake.getTaskBySequenceIDAndApplicationMutex.RLock() + defer fake.getTaskBySequenceIDAndApplicationMutex.RUnlock() + args := make([]FakeActorGetTaskBySequenceIDAndApplicationArgs, len(fake.getTaskBySequenceIDAndApplicationArgsForCall)) + copy(args, fake.getTaskBySequenceIDAndApplicationArgsForCall) + return args } func (fake *FakeActor) GetTaskBySequenceIDAndApplicationReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) { @@ -14940,8 +16859,7 @@ func (fake *FakeActor) GetTaskBySequenceIDAndApplicationReturnsOnCall(i int, res func (fake *FakeActor) GetUAAAPIVersion() (string, error) { fake.getUAAAPIVersionMutex.Lock() ret, specificReturn := fake.getUAAAPIVersionReturnsOnCall[len(fake.getUAAAPIVersionArgsForCall)] - fake.getUAAAPIVersionArgsForCall = append(fake.getUAAAPIVersionArgsForCall, struct { - }{}) + fake.getUAAAPIVersionArgsForCall = append(fake.getUAAAPIVersionArgsForCall, struct{}{}) stub := fake.GetUAAAPIVersionStub fakeReturns := fake.getUAAAPIVersionReturns fake.recordInvocation("GetUAAAPIVersion", []interface{}{}) @@ -14996,9 +16914,7 @@ func (fake *FakeActor) GetUAAAPIVersionReturnsOnCall(i int, result1 string, resu func (fake *FakeActor) GetUnstagedNewestPackageGUID(arg1 string) (string, v7action.Warnings, error) { fake.getUnstagedNewestPackageGUIDMutex.Lock() ret, specificReturn := fake.getUnstagedNewestPackageGUIDReturnsOnCall[len(fake.getUnstagedNewestPackageGUIDArgsForCall)] - fake.getUnstagedNewestPackageGUIDArgsForCall = append(fake.getUnstagedNewestPackageGUIDArgsForCall, struct { - arg1 string - }{arg1}) + fake.getUnstagedNewestPackageGUIDArgsForCall = append(fake.getUnstagedNewestPackageGUIDArgsForCall, FakeActorGetUnstagedNewestPackageGUIDArgs{arg1}) stub := fake.GetUnstagedNewestPackageGUIDStub fakeReturns := fake.getUnstagedNewestPackageGUIDReturns fake.recordInvocation("GetUnstagedNewestPackageGUID", []interface{}{arg1}) @@ -15028,7 +16944,15 @@ func (fake *FakeActor) GetUnstagedNewestPackageGUIDArgsForCall(i int) string { fake.getUnstagedNewestPackageGUIDMutex.RLock() defer fake.getUnstagedNewestPackageGUIDMutex.RUnlock() argsForCall := fake.getUnstagedNewestPackageGUIDArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) GetUnstagedNewestPackageGUIDArgs() []FakeActorGetUnstagedNewestPackageGUIDArgs { + fake.getUnstagedNewestPackageGUIDMutex.RLock() + defer fake.getUnstagedNewestPackageGUIDMutex.RUnlock() + args := make([]FakeActorGetUnstagedNewestPackageGUIDArgs, len(fake.getUnstagedNewestPackageGUIDArgsForCall)) + copy(args, fake.getUnstagedNewestPackageGUIDArgsForCall) + return args } func (fake *FakeActor) GetUnstagedNewestPackageGUIDReturns(result1 string, result2 v7action.Warnings, result3 error) { @@ -15063,10 +16987,7 @@ func (fake *FakeActor) GetUnstagedNewestPackageGUIDReturnsOnCall(i int, result1 func (fake *FakeActor) GetUser(arg1 string, arg2 string) (resources.User, error) { fake.getUserMutex.Lock() ret, specificReturn := fake.getUserReturnsOnCall[len(fake.getUserArgsForCall)] - fake.getUserArgsForCall = append(fake.getUserArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.getUserArgsForCall = append(fake.getUserArgsForCall, FakeActorGetUserArgs{arg1, arg2}) stub := fake.GetUserStub fakeReturns := fake.getUserReturns fake.recordInvocation("GetUser", []interface{}{arg1, arg2}) @@ -15096,7 +17017,15 @@ func (fake *FakeActor) GetUserArgsForCall(i int) (string, string) { fake.getUserMutex.RLock() defer fake.getUserMutex.RUnlock() argsForCall := fake.getUserArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) GetUserArgs() []FakeActorGetUserArgs { + fake.getUserMutex.RLock() + defer fake.getUserMutex.RUnlock() + args := make([]FakeActorGetUserArgs, len(fake.getUserArgsForCall)) + copy(args, fake.getUserArgsForCall) + return args } func (fake *FakeActor) GetUserReturns(result1 resources.User, result2 error) { @@ -15128,9 +17057,7 @@ func (fake *FakeActor) GetUserReturnsOnCall(i int, result1 resources.User, resul func (fake *FakeActor) ListAppBindings(arg1 v7action.ListAppBindingParams) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) { fake.listAppBindingsMutex.Lock() ret, specificReturn := fake.listAppBindingsReturnsOnCall[len(fake.listAppBindingsArgsForCall)] - fake.listAppBindingsArgsForCall = append(fake.listAppBindingsArgsForCall, struct { - arg1 v7action.ListAppBindingParams - }{arg1}) + fake.listAppBindingsArgsForCall = append(fake.listAppBindingsArgsForCall, FakeActorListAppBindingsArgs{arg1}) stub := fake.ListAppBindingsStub fakeReturns := fake.listAppBindingsReturns fake.recordInvocation("ListAppBindings", []interface{}{arg1}) @@ -15160,7 +17087,15 @@ func (fake *FakeActor) ListAppBindingsArgsForCall(i int) v7action.ListAppBinding fake.listAppBindingsMutex.RLock() defer fake.listAppBindingsMutex.RUnlock() argsForCall := fake.listAppBindingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ListAppBindingsArgs() []FakeActorListAppBindingsArgs { + fake.listAppBindingsMutex.RLock() + defer fake.listAppBindingsMutex.RUnlock() + args := make([]FakeActorListAppBindingsArgs, len(fake.listAppBindingsArgsForCall)) + copy(args, fake.listAppBindingsArgsForCall) + return args } func (fake *FakeActor) ListAppBindingsReturns(result1 []resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) { @@ -15195,9 +17130,7 @@ func (fake *FakeActor) ListAppBindingsReturnsOnCall(i int, result1 []resources.S func (fake *FakeActor) ListServiceAppBindings(arg1 v7action.ListServiceAppBindingParams) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) { fake.listServiceAppBindingsMutex.Lock() ret, specificReturn := fake.listServiceAppBindingsReturnsOnCall[len(fake.listServiceAppBindingsArgsForCall)] - fake.listServiceAppBindingsArgsForCall = append(fake.listServiceAppBindingsArgsForCall, struct { - arg1 v7action.ListServiceAppBindingParams - }{arg1}) + fake.listServiceAppBindingsArgsForCall = append(fake.listServiceAppBindingsArgsForCall, FakeActorListServiceAppBindingsArgs{arg1}) stub := fake.ListServiceAppBindingsStub fakeReturns := fake.listServiceAppBindingsReturns fake.recordInvocation("ListServiceAppBindings", []interface{}{arg1}) @@ -15227,7 +17160,15 @@ func (fake *FakeActor) ListServiceAppBindingsArgsForCall(i int) v7action.ListSer fake.listServiceAppBindingsMutex.RLock() defer fake.listServiceAppBindingsMutex.RUnlock() argsForCall := fake.listServiceAppBindingsArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ListServiceAppBindingsArgs() []FakeActorListServiceAppBindingsArgs { + fake.listServiceAppBindingsMutex.RLock() + defer fake.listServiceAppBindingsMutex.RUnlock() + args := make([]FakeActorListServiceAppBindingsArgs, len(fake.listServiceAppBindingsArgsForCall)) + copy(args, fake.listServiceAppBindingsArgsForCall) + return args } func (fake *FakeActor) ListServiceAppBindingsReturns(result1 []resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) { @@ -15267,13 +17208,7 @@ func (fake *FakeActor) MakeCurlRequest(arg1 string, arg2 string, arg3 []string, } fake.makeCurlRequestMutex.Lock() ret, specificReturn := fake.makeCurlRequestReturnsOnCall[len(fake.makeCurlRequestArgsForCall)] - fake.makeCurlRequestArgsForCall = append(fake.makeCurlRequestArgsForCall, struct { - arg1 string - arg2 string - arg3 []string - arg4 string - arg5 bool - }{arg1, arg2, arg3Copy, arg4, arg5}) + fake.makeCurlRequestArgsForCall = append(fake.makeCurlRequestArgsForCall, FakeActorMakeCurlRequestArgs{arg1, arg2, arg3Copy, arg4, arg5}) stub := fake.MakeCurlRequestStub fakeReturns := fake.makeCurlRequestReturns fake.recordInvocation("MakeCurlRequest", []interface{}{arg1, arg2, arg3Copy, arg4, arg5}) @@ -15303,7 +17238,15 @@ func (fake *FakeActor) MakeCurlRequestArgsForCall(i int) (string, string, []stri fake.makeCurlRequestMutex.RLock() defer fake.makeCurlRequestMutex.RUnlock() argsForCall := fake.makeCurlRequestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5 +} + +func (fake *FakeActor) MakeCurlRequestArgs() []FakeActorMakeCurlRequestArgs { + fake.makeCurlRequestMutex.RLock() + defer fake.makeCurlRequestMutex.RUnlock() + args := make([]FakeActorMakeCurlRequestArgs, len(fake.makeCurlRequestArgsForCall)) + copy(args, fake.makeCurlRequestArgsForCall) + return args } func (fake *FakeActor) MakeCurlRequestReturns(result1 []byte, result2 *http.Response, result3 error) { @@ -15338,12 +17281,7 @@ func (fake *FakeActor) MakeCurlRequestReturnsOnCall(i int, result1 []byte, resul func (fake *FakeActor) MapRoute(arg1 string, arg2 string, arg3 string, arg4 int) (v7action.Warnings, error) { fake.mapRouteMutex.Lock() ret, specificReturn := fake.mapRouteReturnsOnCall[len(fake.mapRouteArgsForCall)] - fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 int - }{arg1, arg2, arg3, arg4}) + fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, FakeActorMapRouteArgs{arg1, arg2, arg3, arg4}) stub := fake.MapRouteStub fakeReturns := fake.mapRouteReturns fake.recordInvocation("MapRoute", []interface{}{arg1, arg2, arg3, arg4}) @@ -15373,7 +17311,15 @@ func (fake *FakeActor) MapRouteArgsForCall(i int) (string, string, string, int) fake.mapRouteMutex.RLock() defer fake.mapRouteMutex.RUnlock() argsForCall := fake.mapRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) MapRouteArgs() []FakeActorMapRouteArgs { + fake.mapRouteMutex.RLock() + defer fake.mapRouteMutex.RUnlock() + args := make([]FakeActorMapRouteArgs, len(fake.mapRouteArgsForCall)) + copy(args, fake.mapRouteArgsForCall) + return args } func (fake *FakeActor) MapRouteReturns(result1 v7action.Warnings, result2 error) { @@ -15405,9 +17351,7 @@ func (fake *FakeActor) MapRouteReturnsOnCall(i int, result1 v7action.Warnings, r func (fake *FakeActor) Marketplace(arg1 v7action.MarketplaceFilter) ([]v7action.ServiceOfferingWithPlans, v7action.Warnings, error) { fake.marketplaceMutex.Lock() ret, specificReturn := fake.marketplaceReturnsOnCall[len(fake.marketplaceArgsForCall)] - fake.marketplaceArgsForCall = append(fake.marketplaceArgsForCall, struct { - arg1 v7action.MarketplaceFilter - }{arg1}) + fake.marketplaceArgsForCall = append(fake.marketplaceArgsForCall, FakeActorMarketplaceArgs{arg1}) stub := fake.MarketplaceStub fakeReturns := fake.marketplaceReturns fake.recordInvocation("Marketplace", []interface{}{arg1}) @@ -15437,7 +17381,15 @@ func (fake *FakeActor) MarketplaceArgsForCall(i int) v7action.MarketplaceFilter fake.marketplaceMutex.RLock() defer fake.marketplaceMutex.RUnlock() argsForCall := fake.marketplaceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) MarketplaceArgs() []FakeActorMarketplaceArgs { + fake.marketplaceMutex.RLock() + defer fake.marketplaceMutex.RUnlock() + args := make([]FakeActorMarketplaceArgs, len(fake.marketplaceArgsForCall)) + copy(args, fake.marketplaceArgsForCall) + return args } func (fake *FakeActor) MarketplaceReturns(result1 []v7action.ServiceOfferingWithPlans, result2 v7action.Warnings, result3 error) { @@ -15472,10 +17424,7 @@ func (fake *FakeActor) MarketplaceReturnsOnCall(i int, result1 []v7action.Servic func (fake *FakeActor) MoveRoute(arg1 string, arg2 string) (v7action.Warnings, error) { fake.moveRouteMutex.Lock() ret, specificReturn := fake.moveRouteReturnsOnCall[len(fake.moveRouteArgsForCall)] - fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, FakeActorMoveRouteArgs{arg1, arg2}) stub := fake.MoveRouteStub fakeReturns := fake.moveRouteReturns fake.recordInvocation("MoveRoute", []interface{}{arg1, arg2}) @@ -15505,7 +17454,15 @@ func (fake *FakeActor) MoveRouteArgsForCall(i int) (string, string) { fake.moveRouteMutex.RLock() defer fake.moveRouteMutex.RUnlock() argsForCall := fake.moveRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) MoveRouteArgs() []FakeActorMoveRouteArgs { + fake.moveRouteMutex.RLock() + defer fake.moveRouteMutex.RUnlock() + args := make([]FakeActorMoveRouteArgs, len(fake.moveRouteArgsForCall)) + copy(args, fake.moveRouteArgsForCall) + return args } func (fake *FakeActor) MoveRouteReturns(result1 v7action.Warnings, result2 error) { @@ -15534,12 +17491,10 @@ func (fake *FakeActor) MoveRouteReturnsOnCall(i int, result1 v7action.Warnings, }{result1, result2} } -func (fake *FakeActor) ParseAccessToken(arg1 string) (jwtv5.MapClaims, error) { +func (fake *FakeActor) ParseAccessToken(arg1 string) (jwt.MapClaims, error) { fake.parseAccessTokenMutex.Lock() ret, specificReturn := fake.parseAccessTokenReturnsOnCall[len(fake.parseAccessTokenArgsForCall)] - fake.parseAccessTokenArgsForCall = append(fake.parseAccessTokenArgsForCall, struct { - arg1 string - }{arg1}) + fake.parseAccessTokenArgsForCall = append(fake.parseAccessTokenArgsForCall, FakeActorParseAccessTokenArgs{arg1}) stub := fake.ParseAccessTokenStub fakeReturns := fake.parseAccessTokenReturns fake.recordInvocation("ParseAccessToken", []interface{}{arg1}) @@ -15559,7 +17514,7 @@ func (fake *FakeActor) ParseAccessTokenCallCount() int { return len(fake.parseAccessTokenArgsForCall) } -func (fake *FakeActor) ParseAccessTokenCalls(stub func(string) (jwtv5.MapClaims, error)) { +func (fake *FakeActor) ParseAccessTokenCalls(stub func(string) (jwt.MapClaims, error)) { fake.parseAccessTokenMutex.Lock() defer fake.parseAccessTokenMutex.Unlock() fake.ParseAccessTokenStub = stub @@ -15569,31 +17524,39 @@ func (fake *FakeActor) ParseAccessTokenArgsForCall(i int) string { fake.parseAccessTokenMutex.RLock() defer fake.parseAccessTokenMutex.RUnlock() argsForCall := fake.parseAccessTokenArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ParseAccessTokenArgs() []FakeActorParseAccessTokenArgs { + fake.parseAccessTokenMutex.RLock() + defer fake.parseAccessTokenMutex.RUnlock() + args := make([]FakeActorParseAccessTokenArgs, len(fake.parseAccessTokenArgsForCall)) + copy(args, fake.parseAccessTokenArgsForCall) + return args } -func (fake *FakeActor) ParseAccessTokenReturns(result1 jwtv5.MapClaims, result2 error) { +func (fake *FakeActor) ParseAccessTokenReturns(result1 jwt.MapClaims, result2 error) { fake.parseAccessTokenMutex.Lock() defer fake.parseAccessTokenMutex.Unlock() fake.ParseAccessTokenStub = nil fake.parseAccessTokenReturns = struct { - result1 jwtv5.MapClaims + result1 jwt.MapClaims result2 error }{result1, result2} } -func (fake *FakeActor) ParseAccessTokenReturnsOnCall(i int, result1 jwtv5.MapClaims, result2 error) { +func (fake *FakeActor) ParseAccessTokenReturnsOnCall(i int, result1 jwt.MapClaims, result2 error) { fake.parseAccessTokenMutex.Lock() defer fake.parseAccessTokenMutex.Unlock() fake.ParseAccessTokenStub = nil if fake.parseAccessTokenReturnsOnCall == nil { fake.parseAccessTokenReturnsOnCall = make(map[int]struct { - result1 jwtv5.MapClaims + result1 jwt.MapClaims result2 error }) } fake.parseAccessTokenReturnsOnCall[i] = struct { - result1 jwtv5.MapClaims + result1 jwt.MapClaims result2 error }{result1, result2} } @@ -15601,10 +17564,7 @@ func (fake *FakeActor) ParseAccessTokenReturnsOnCall(i int, result1 jwtv5.MapCla func (fake *FakeActor) PollBuild(arg1 string, arg2 string) (resources.Droplet, v7action.Warnings, error) { fake.pollBuildMutex.Lock() ret, specificReturn := fake.pollBuildReturnsOnCall[len(fake.pollBuildArgsForCall)] - fake.pollBuildArgsForCall = append(fake.pollBuildArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.pollBuildArgsForCall = append(fake.pollBuildArgsForCall, FakeActorPollBuildArgs{arg1, arg2}) stub := fake.PollBuildStub fakeReturns := fake.pollBuildReturns fake.recordInvocation("PollBuild", []interface{}{arg1, arg2}) @@ -15634,7 +17594,15 @@ func (fake *FakeActor) PollBuildArgsForCall(i int) (string, string) { fake.pollBuildMutex.RLock() defer fake.pollBuildMutex.RUnlock() argsForCall := fake.pollBuildArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) PollBuildArgs() []FakeActorPollBuildArgs { + fake.pollBuildMutex.RLock() + defer fake.pollBuildMutex.RUnlock() + args := make([]FakeActorPollBuildArgs, len(fake.pollBuildArgsForCall)) + copy(args, fake.pollBuildArgsForCall) + return args } func (fake *FakeActor) PollBuildReturns(result1 resources.Droplet, result2 v7action.Warnings, result3 error) { @@ -15669,9 +17637,7 @@ func (fake *FakeActor) PollBuildReturnsOnCall(i int, result1 resources.Droplet, func (fake *FakeActor) PollPackage(arg1 resources.Package) (resources.Package, v7action.Warnings, error) { fake.pollPackageMutex.Lock() ret, specificReturn := fake.pollPackageReturnsOnCall[len(fake.pollPackageArgsForCall)] - fake.pollPackageArgsForCall = append(fake.pollPackageArgsForCall, struct { - arg1 resources.Package - }{arg1}) + fake.pollPackageArgsForCall = append(fake.pollPackageArgsForCall, FakeActorPollPackageArgs{arg1}) stub := fake.PollPackageStub fakeReturns := fake.pollPackageReturns fake.recordInvocation("PollPackage", []interface{}{arg1}) @@ -15701,7 +17667,15 @@ func (fake *FakeActor) PollPackageArgsForCall(i int) resources.Package { fake.pollPackageMutex.RLock() defer fake.pollPackageMutex.RUnlock() argsForCall := fake.pollPackageArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) PollPackageArgs() []FakeActorPollPackageArgs { + fake.pollPackageMutex.RLock() + defer fake.pollPackageMutex.RUnlock() + args := make([]FakeActorPollPackageArgs, len(fake.pollPackageArgsForCall)) + copy(args, fake.pollPackageArgsForCall) + return args } func (fake *FakeActor) PollPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -15736,11 +17710,7 @@ func (fake *FakeActor) PollPackageReturnsOnCall(i int, result1 resources.Package func (fake *FakeActor) PollStart(arg1 resources.Application, arg2 bool, arg3 func(string)) (v7action.Warnings, error) { fake.pollStartMutex.Lock() ret, specificReturn := fake.pollStartReturnsOnCall[len(fake.pollStartArgsForCall)] - fake.pollStartArgsForCall = append(fake.pollStartArgsForCall, struct { - arg1 resources.Application - arg2 bool - arg3 func(string) - }{arg1, arg2, arg3}) + fake.pollStartArgsForCall = append(fake.pollStartArgsForCall, FakeActorPollStartArgs{arg1, arg2, arg3}) stub := fake.PollStartStub fakeReturns := fake.pollStartReturns fake.recordInvocation("PollStart", []interface{}{arg1, arg2, arg3}) @@ -15770,7 +17740,15 @@ func (fake *FakeActor) PollStartArgsForCall(i int) (resources.Application, bool, fake.pollStartMutex.RLock() defer fake.pollStartMutex.RUnlock() argsForCall := fake.pollStartArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) PollStartArgs() []FakeActorPollStartArgs { + fake.pollStartMutex.RLock() + defer fake.pollStartMutex.RUnlock() + args := make([]FakeActorPollStartArgs, len(fake.pollStartArgsForCall)) + copy(args, fake.pollStartArgsForCall) + return args } func (fake *FakeActor) PollStartReturns(result1 v7action.Warnings, result2 error) { @@ -15802,12 +17780,7 @@ func (fake *FakeActor) PollStartReturnsOnCall(i int, result1 v7action.Warnings, func (fake *FakeActor) PollStartForDeployment(arg1 resources.Application, arg2 string, arg3 bool, arg4 func(string)) (v7action.Warnings, error) { fake.pollStartForDeploymentMutex.Lock() ret, specificReturn := fake.pollStartForDeploymentReturnsOnCall[len(fake.pollStartForDeploymentArgsForCall)] - fake.pollStartForDeploymentArgsForCall = append(fake.pollStartForDeploymentArgsForCall, struct { - arg1 resources.Application - arg2 string - arg3 bool - arg4 func(string) - }{arg1, arg2, arg3, arg4}) + fake.pollStartForDeploymentArgsForCall = append(fake.pollStartForDeploymentArgsForCall, FakeActorPollStartForDeploymentArgs{arg1, arg2, arg3, arg4}) stub := fake.PollStartForDeploymentStub fakeReturns := fake.pollStartForDeploymentReturns fake.recordInvocation("PollStartForDeployment", []interface{}{arg1, arg2, arg3, arg4}) @@ -15837,7 +17810,15 @@ func (fake *FakeActor) PollStartForDeploymentArgsForCall(i int) (resources.Appli fake.pollStartForDeploymentMutex.RLock() defer fake.pollStartForDeploymentMutex.RUnlock() argsForCall := fake.pollStartForDeploymentArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) PollStartForDeploymentArgs() []FakeActorPollStartForDeploymentArgs { + fake.pollStartForDeploymentMutex.RLock() + defer fake.pollStartForDeploymentMutex.RUnlock() + args := make([]FakeActorPollStartForDeploymentArgs, len(fake.pollStartForDeploymentArgsForCall)) + copy(args, fake.pollStartForDeploymentArgsForCall) + return args } func (fake *FakeActor) PollStartForDeploymentReturns(result1 v7action.Warnings, result2 error) { @@ -15869,9 +17850,7 @@ func (fake *FakeActor) PollStartForDeploymentReturnsOnCall(i int, result1 v7acti func (fake *FakeActor) PollTask(arg1 resources.Task) (resources.Task, v7action.Warnings, error) { fake.pollTaskMutex.Lock() ret, specificReturn := fake.pollTaskReturnsOnCall[len(fake.pollTaskArgsForCall)] - fake.pollTaskArgsForCall = append(fake.pollTaskArgsForCall, struct { - arg1 resources.Task - }{arg1}) + fake.pollTaskArgsForCall = append(fake.pollTaskArgsForCall, FakeActorPollTaskArgs{arg1}) stub := fake.PollTaskStub fakeReturns := fake.pollTaskReturns fake.recordInvocation("PollTask", []interface{}{arg1}) @@ -15901,7 +17880,15 @@ func (fake *FakeActor) PollTaskArgsForCall(i int) resources.Task { fake.pollTaskMutex.RLock() defer fake.pollTaskMutex.RUnlock() argsForCall := fake.pollTaskArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) PollTaskArgs() []FakeActorPollTaskArgs { + fake.pollTaskMutex.RLock() + defer fake.pollTaskMutex.RUnlock() + args := make([]FakeActorPollTaskArgs, len(fake.pollTaskArgsForCall)) + copy(args, fake.pollTaskArgsForCall) + return args } func (fake *FakeActor) PollTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) { @@ -15936,9 +17923,7 @@ func (fake *FakeActor) PollTaskReturnsOnCall(i int, result1 resources.Task, resu func (fake *FakeActor) PollUploadBuildpackJob(arg1 ccv3.JobURL) (v7action.Warnings, error) { fake.pollUploadBuildpackJobMutex.Lock() ret, specificReturn := fake.pollUploadBuildpackJobReturnsOnCall[len(fake.pollUploadBuildpackJobArgsForCall)] - fake.pollUploadBuildpackJobArgsForCall = append(fake.pollUploadBuildpackJobArgsForCall, struct { - arg1 ccv3.JobURL - }{arg1}) + fake.pollUploadBuildpackJobArgsForCall = append(fake.pollUploadBuildpackJobArgsForCall, FakeActorPollUploadBuildpackJobArgs{arg1}) stub := fake.PollUploadBuildpackJobStub fakeReturns := fake.pollUploadBuildpackJobReturns fake.recordInvocation("PollUploadBuildpackJob", []interface{}{arg1}) @@ -15968,7 +17953,15 @@ func (fake *FakeActor) PollUploadBuildpackJobArgsForCall(i int) ccv3.JobURL { fake.pollUploadBuildpackJobMutex.RLock() defer fake.pollUploadBuildpackJobMutex.RUnlock() argsForCall := fake.pollUploadBuildpackJobArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) PollUploadBuildpackJobArgs() []FakeActorPollUploadBuildpackJobArgs { + fake.pollUploadBuildpackJobMutex.RLock() + defer fake.pollUploadBuildpackJobMutex.RUnlock() + args := make([]FakeActorPollUploadBuildpackJobArgs, len(fake.pollUploadBuildpackJobArgsForCall)) + copy(args, fake.pollUploadBuildpackJobArgsForCall) + return args } func (fake *FakeActor) PollUploadBuildpackJobReturns(result1 v7action.Warnings, result2 error) { @@ -16000,11 +17993,7 @@ func (fake *FakeActor) PollUploadBuildpackJobReturnsOnCall(i int, result1 v7acti func (fake *FakeActor) PrepareBuildpackBits(arg1 string, arg2 string, arg3 v7action.Downloader) (string, error) { fake.prepareBuildpackBitsMutex.Lock() ret, specificReturn := fake.prepareBuildpackBitsReturnsOnCall[len(fake.prepareBuildpackBitsArgsForCall)] - fake.prepareBuildpackBitsArgsForCall = append(fake.prepareBuildpackBitsArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.Downloader - }{arg1, arg2, arg3}) + fake.prepareBuildpackBitsArgsForCall = append(fake.prepareBuildpackBitsArgsForCall, FakeActorPrepareBuildpackBitsArgs{arg1, arg2, arg3}) stub := fake.PrepareBuildpackBitsStub fakeReturns := fake.prepareBuildpackBitsReturns fake.recordInvocation("PrepareBuildpackBits", []interface{}{arg1, arg2, arg3}) @@ -16034,7 +18023,15 @@ func (fake *FakeActor) PrepareBuildpackBitsArgsForCall(i int) (string, string, v fake.prepareBuildpackBitsMutex.RLock() defer fake.prepareBuildpackBitsMutex.RUnlock() argsForCall := fake.prepareBuildpackBitsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) PrepareBuildpackBitsArgs() []FakeActorPrepareBuildpackBitsArgs { + fake.prepareBuildpackBitsMutex.RLock() + defer fake.prepareBuildpackBitsMutex.RUnlock() + args := make([]FakeActorPrepareBuildpackBitsArgs, len(fake.prepareBuildpackBitsArgsForCall)) + copy(args, fake.prepareBuildpackBitsArgsForCall) + return args } func (fake *FakeActor) PrepareBuildpackBitsReturns(result1 string, result2 error) { @@ -16066,10 +18063,7 @@ func (fake *FakeActor) PrepareBuildpackBitsReturnsOnCall(i int, result1 string, func (fake *FakeActor) PurgeServiceInstance(arg1 string, arg2 string) (v7action.Warnings, error) { fake.purgeServiceInstanceMutex.Lock() ret, specificReturn := fake.purgeServiceInstanceReturnsOnCall[len(fake.purgeServiceInstanceArgsForCall)] - fake.purgeServiceInstanceArgsForCall = append(fake.purgeServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.purgeServiceInstanceArgsForCall = append(fake.purgeServiceInstanceArgsForCall, FakeActorPurgeServiceInstanceArgs{arg1, arg2}) stub := fake.PurgeServiceInstanceStub fakeReturns := fake.purgeServiceInstanceReturns fake.recordInvocation("PurgeServiceInstance", []interface{}{arg1, arg2}) @@ -16099,7 +18093,15 @@ func (fake *FakeActor) PurgeServiceInstanceArgsForCall(i int) (string, string) { fake.purgeServiceInstanceMutex.RLock() defer fake.purgeServiceInstanceMutex.RUnlock() argsForCall := fake.purgeServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) PurgeServiceInstanceArgs() []FakeActorPurgeServiceInstanceArgs { + fake.purgeServiceInstanceMutex.RLock() + defer fake.purgeServiceInstanceMutex.RUnlock() + args := make([]FakeActorPurgeServiceInstanceArgs, len(fake.purgeServiceInstanceArgsForCall)) + copy(args, fake.purgeServiceInstanceArgsForCall) + return args } func (fake *FakeActor) PurgeServiceInstanceReturns(result1 v7action.Warnings, result2 error) { @@ -16131,10 +18133,7 @@ func (fake *FakeActor) PurgeServiceInstanceReturnsOnCall(i int, result1 v7action func (fake *FakeActor) PurgeServiceOfferingByNameAndBroker(arg1 string, arg2 string) (v7action.Warnings, error) { fake.purgeServiceOfferingByNameAndBrokerMutex.Lock() ret, specificReturn := fake.purgeServiceOfferingByNameAndBrokerReturnsOnCall[len(fake.purgeServiceOfferingByNameAndBrokerArgsForCall)] - fake.purgeServiceOfferingByNameAndBrokerArgsForCall = append(fake.purgeServiceOfferingByNameAndBrokerArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.purgeServiceOfferingByNameAndBrokerArgsForCall = append(fake.purgeServiceOfferingByNameAndBrokerArgsForCall, FakeActorPurgeServiceOfferingByNameAndBrokerArgs{arg1, arg2}) stub := fake.PurgeServiceOfferingByNameAndBrokerStub fakeReturns := fake.purgeServiceOfferingByNameAndBrokerReturns fake.recordInvocation("PurgeServiceOfferingByNameAndBroker", []interface{}{arg1, arg2}) @@ -16164,7 +18163,15 @@ func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerArgsForCall(i int) (st fake.purgeServiceOfferingByNameAndBrokerMutex.RLock() defer fake.purgeServiceOfferingByNameAndBrokerMutex.RUnlock() argsForCall := fake.purgeServiceOfferingByNameAndBrokerArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerArgs() []FakeActorPurgeServiceOfferingByNameAndBrokerArgs { + fake.purgeServiceOfferingByNameAndBrokerMutex.RLock() + defer fake.purgeServiceOfferingByNameAndBrokerMutex.RUnlock() + args := make([]FakeActorPurgeServiceOfferingByNameAndBrokerArgs, len(fake.purgeServiceOfferingByNameAndBrokerArgsForCall)) + copy(args, fake.purgeServiceOfferingByNameAndBrokerArgsForCall) + return args } func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerReturns(result1 v7action.Warnings, result2 error) { @@ -16196,8 +18203,7 @@ func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerReturnsOnCall(i int, r func (fake *FakeActor) RefreshAccessToken() (string, error) { fake.refreshAccessTokenMutex.Lock() ret, specificReturn := fake.refreshAccessTokenReturnsOnCall[len(fake.refreshAccessTokenArgsForCall)] - fake.refreshAccessTokenArgsForCall = append(fake.refreshAccessTokenArgsForCall, struct { - }{}) + fake.refreshAccessTokenArgsForCall = append(fake.refreshAccessTokenArgsForCall, struct{}{}) stub := fake.RefreshAccessTokenStub fakeReturns := fake.refreshAccessTokenReturns fake.recordInvocation("RefreshAccessToken", []interface{}{}) @@ -16252,11 +18258,7 @@ func (fake *FakeActor) RefreshAccessTokenReturnsOnCall(i int, result1 string, re func (fake *FakeActor) RenameApplicationByNameAndSpaceGUID(arg1 string, arg2 string, arg3 string) (resources.Application, v7action.Warnings, error) { fake.renameApplicationByNameAndSpaceGUIDMutex.Lock() ret, specificReturn := fake.renameApplicationByNameAndSpaceGUIDReturnsOnCall[len(fake.renameApplicationByNameAndSpaceGUIDArgsForCall)] - fake.renameApplicationByNameAndSpaceGUIDArgsForCall = append(fake.renameApplicationByNameAndSpaceGUIDArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.renameApplicationByNameAndSpaceGUIDArgsForCall = append(fake.renameApplicationByNameAndSpaceGUIDArgsForCall, FakeActorRenameApplicationByNameAndSpaceGUIDArgs{arg1, arg2, arg3}) stub := fake.RenameApplicationByNameAndSpaceGUIDStub fakeReturns := fake.renameApplicationByNameAndSpaceGUIDReturns fake.recordInvocation("RenameApplicationByNameAndSpaceGUID", []interface{}{arg1, arg2, arg3}) @@ -16286,7 +18288,15 @@ func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDArgsForCall(i int) (st fake.renameApplicationByNameAndSpaceGUIDMutex.RLock() defer fake.renameApplicationByNameAndSpaceGUIDMutex.RUnlock() argsForCall := fake.renameApplicationByNameAndSpaceGUIDArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDArgs() []FakeActorRenameApplicationByNameAndSpaceGUIDArgs { + fake.renameApplicationByNameAndSpaceGUIDMutex.RLock() + defer fake.renameApplicationByNameAndSpaceGUIDMutex.RUnlock() + args := make([]FakeActorRenameApplicationByNameAndSpaceGUIDArgs, len(fake.renameApplicationByNameAndSpaceGUIDArgsForCall)) + copy(args, fake.renameApplicationByNameAndSpaceGUIDArgsForCall) + return args } func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) { @@ -16321,10 +18331,7 @@ func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDReturnsOnCall(i int, r func (fake *FakeActor) RenameOrganization(arg1 string, arg2 string) (resources.Organization, v7action.Warnings, error) { fake.renameOrganizationMutex.Lock() ret, specificReturn := fake.renameOrganizationReturnsOnCall[len(fake.renameOrganizationArgsForCall)] - fake.renameOrganizationArgsForCall = append(fake.renameOrganizationArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.renameOrganizationArgsForCall = append(fake.renameOrganizationArgsForCall, FakeActorRenameOrganizationArgs{arg1, arg2}) stub := fake.RenameOrganizationStub fakeReturns := fake.renameOrganizationReturns fake.recordInvocation("RenameOrganization", []interface{}{arg1, arg2}) @@ -16354,7 +18361,15 @@ func (fake *FakeActor) RenameOrganizationArgsForCall(i int) (string, string) { fake.renameOrganizationMutex.RLock() defer fake.renameOrganizationMutex.RUnlock() argsForCall := fake.renameOrganizationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) RenameOrganizationArgs() []FakeActorRenameOrganizationArgs { + fake.renameOrganizationMutex.RLock() + defer fake.renameOrganizationMutex.RUnlock() + args := make([]FakeActorRenameOrganizationArgs, len(fake.renameOrganizationArgsForCall)) + copy(args, fake.renameOrganizationArgsForCall) + return args } func (fake *FakeActor) RenameOrganizationReturns(result1 resources.Organization, result2 v7action.Warnings, result3 error) { @@ -16389,11 +18404,7 @@ func (fake *FakeActor) RenameOrganizationReturnsOnCall(i int, result1 resources. func (fake *FakeActor) RenameServiceInstance(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.renameServiceInstanceMutex.Lock() ret, specificReturn := fake.renameServiceInstanceReturnsOnCall[len(fake.renameServiceInstanceArgsForCall)] - fake.renameServiceInstanceArgsForCall = append(fake.renameServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.renameServiceInstanceArgsForCall = append(fake.renameServiceInstanceArgsForCall, FakeActorRenameServiceInstanceArgs{arg1, arg2, arg3}) stub := fake.RenameServiceInstanceStub fakeReturns := fake.renameServiceInstanceReturns fake.recordInvocation("RenameServiceInstance", []interface{}{arg1, arg2, arg3}) @@ -16423,7 +18434,15 @@ func (fake *FakeActor) RenameServiceInstanceArgsForCall(i int) (string, string, fake.renameServiceInstanceMutex.RLock() defer fake.renameServiceInstanceMutex.RUnlock() argsForCall := fake.renameServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) RenameServiceInstanceArgs() []FakeActorRenameServiceInstanceArgs { + fake.renameServiceInstanceMutex.RLock() + defer fake.renameServiceInstanceMutex.RUnlock() + args := make([]FakeActorRenameServiceInstanceArgs, len(fake.renameServiceInstanceArgsForCall)) + copy(args, fake.renameServiceInstanceArgsForCall) + return args } func (fake *FakeActor) RenameServiceInstanceReturns(result1 v7action.Warnings, result2 error) { @@ -16455,11 +18474,7 @@ func (fake *FakeActor) RenameServiceInstanceReturnsOnCall(i int, result1 v7actio func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUID(arg1 string, arg2 string, arg3 string) (resources.Space, v7action.Warnings, error) { fake.renameSpaceByNameAndOrganizationGUIDMutex.Lock() ret, specificReturn := fake.renameSpaceByNameAndOrganizationGUIDReturnsOnCall[len(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall)] - fake.renameSpaceByNameAndOrganizationGUIDArgsForCall = append(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.renameSpaceByNameAndOrganizationGUIDArgsForCall = append(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall, FakeActorRenameSpaceByNameAndOrganizationGUIDArgs{arg1, arg2, arg3}) stub := fake.RenameSpaceByNameAndOrganizationGUIDStub fakeReturns := fake.renameSpaceByNameAndOrganizationGUIDReturns fake.recordInvocation("RenameSpaceByNameAndOrganizationGUID", []interface{}{arg1, arg2, arg3}) @@ -16489,7 +18504,15 @@ func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDArgsForCall(i int) (s fake.renameSpaceByNameAndOrganizationGUIDMutex.RLock() defer fake.renameSpaceByNameAndOrganizationGUIDMutex.RUnlock() argsForCall := fake.renameSpaceByNameAndOrganizationGUIDArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDArgs() []FakeActorRenameSpaceByNameAndOrganizationGUIDArgs { + fake.renameSpaceByNameAndOrganizationGUIDMutex.RLock() + defer fake.renameSpaceByNameAndOrganizationGUIDMutex.RUnlock() + args := make([]FakeActorRenameSpaceByNameAndOrganizationGUIDArgs, len(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall)) + copy(args, fake.renameSpaceByNameAndOrganizationGUIDArgsForCall) + return args } func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDReturns(result1 resources.Space, result2 v7action.Warnings, result3 error) { @@ -16524,9 +18547,7 @@ func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDReturnsOnCall(i int, func (fake *FakeActor) ResetOrganizationDefaultIsolationSegment(arg1 string) (v7action.Warnings, error) { fake.resetOrganizationDefaultIsolationSegmentMutex.Lock() ret, specificReturn := fake.resetOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.resetOrganizationDefaultIsolationSegmentArgsForCall)] - fake.resetOrganizationDefaultIsolationSegmentArgsForCall = append(fake.resetOrganizationDefaultIsolationSegmentArgsForCall, struct { - arg1 string - }{arg1}) + fake.resetOrganizationDefaultIsolationSegmentArgsForCall = append(fake.resetOrganizationDefaultIsolationSegmentArgsForCall, FakeActorResetOrganizationDefaultIsolationSegmentArgs{arg1}) stub := fake.ResetOrganizationDefaultIsolationSegmentStub fakeReturns := fake.resetOrganizationDefaultIsolationSegmentReturns fake.recordInvocation("ResetOrganizationDefaultIsolationSegment", []interface{}{arg1}) @@ -16556,7 +18577,15 @@ func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentArgsForCall(i int fake.resetOrganizationDefaultIsolationSegmentMutex.RLock() defer fake.resetOrganizationDefaultIsolationSegmentMutex.RUnlock() argsForCall := fake.resetOrganizationDefaultIsolationSegmentArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentArgs() []FakeActorResetOrganizationDefaultIsolationSegmentArgs { + fake.resetOrganizationDefaultIsolationSegmentMutex.RLock() + defer fake.resetOrganizationDefaultIsolationSegmentMutex.RUnlock() + args := make([]FakeActorResetOrganizationDefaultIsolationSegmentArgs, len(fake.resetOrganizationDefaultIsolationSegmentArgsForCall)) + copy(args, fake.resetOrganizationDefaultIsolationSegmentArgsForCall) + return args } func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentReturns(result1 v7action.Warnings, result2 error) { @@ -16588,10 +18617,7 @@ func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentReturnsOnCall(i i func (fake *FakeActor) ResetSpaceIsolationSegment(arg1 string, arg2 string) (string, v7action.Warnings, error) { fake.resetSpaceIsolationSegmentMutex.Lock() ret, specificReturn := fake.resetSpaceIsolationSegmentReturnsOnCall[len(fake.resetSpaceIsolationSegmentArgsForCall)] - fake.resetSpaceIsolationSegmentArgsForCall = append(fake.resetSpaceIsolationSegmentArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.resetSpaceIsolationSegmentArgsForCall = append(fake.resetSpaceIsolationSegmentArgsForCall, FakeActorResetSpaceIsolationSegmentArgs{arg1, arg2}) stub := fake.ResetSpaceIsolationSegmentStub fakeReturns := fake.resetSpaceIsolationSegmentReturns fake.recordInvocation("ResetSpaceIsolationSegment", []interface{}{arg1, arg2}) @@ -16621,7 +18647,15 @@ func (fake *FakeActor) ResetSpaceIsolationSegmentArgsForCall(i int) (string, str fake.resetSpaceIsolationSegmentMutex.RLock() defer fake.resetSpaceIsolationSegmentMutex.RUnlock() argsForCall := fake.resetSpaceIsolationSegmentArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) ResetSpaceIsolationSegmentArgs() []FakeActorResetSpaceIsolationSegmentArgs { + fake.resetSpaceIsolationSegmentMutex.RLock() + defer fake.resetSpaceIsolationSegmentMutex.RUnlock() + args := make([]FakeActorResetSpaceIsolationSegmentArgs, len(fake.resetSpaceIsolationSegmentArgsForCall)) + copy(args, fake.resetSpaceIsolationSegmentArgsForCall) + return args } func (fake *FakeActor) ResetSpaceIsolationSegmentReturns(result1 string, result2 v7action.Warnings, result3 error) { @@ -16661,9 +18695,7 @@ func (fake *FakeActor) ResourceMatch(arg1 []sharedaction.V3Resource) ([]sharedac } fake.resourceMatchMutex.Lock() ret, specificReturn := fake.resourceMatchReturnsOnCall[len(fake.resourceMatchArgsForCall)] - fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, struct { - arg1 []sharedaction.V3Resource - }{arg1Copy}) + fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, FakeActorResourceMatchArgs{arg1Copy}) stub := fake.ResourceMatchStub fakeReturns := fake.resourceMatchReturns fake.recordInvocation("ResourceMatch", []interface{}{arg1Copy}) @@ -16693,7 +18725,15 @@ func (fake *FakeActor) ResourceMatchArgsForCall(i int) []sharedaction.V3Resource fake.resourceMatchMutex.RLock() defer fake.resourceMatchMutex.RUnlock() argsForCall := fake.resourceMatchArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) ResourceMatchArgs() []FakeActorResourceMatchArgs { + fake.resourceMatchMutex.RLock() + defer fake.resourceMatchMutex.RUnlock() + args := make([]FakeActorResourceMatchArgs, len(fake.resourceMatchArgsForCall)) + copy(args, fake.resourceMatchArgsForCall) + return args } func (fake *FakeActor) ResourceMatchReturns(result1 []sharedaction.V3Resource, result2 v7action.Warnings, result3 error) { @@ -16728,10 +18768,7 @@ func (fake *FakeActor) ResourceMatchReturnsOnCall(i int, result1 []sharedaction. func (fake *FakeActor) RestartApplication(arg1 string, arg2 bool) (v7action.Warnings, error) { fake.restartApplicationMutex.Lock() ret, specificReturn := fake.restartApplicationReturnsOnCall[len(fake.restartApplicationArgsForCall)] - fake.restartApplicationArgsForCall = append(fake.restartApplicationArgsForCall, struct { - arg1 string - arg2 bool - }{arg1, arg2}) + fake.restartApplicationArgsForCall = append(fake.restartApplicationArgsForCall, FakeActorRestartApplicationArgs{arg1, arg2}) stub := fake.RestartApplicationStub fakeReturns := fake.restartApplicationReturns fake.recordInvocation("RestartApplication", []interface{}{arg1, arg2}) @@ -16761,7 +18798,15 @@ func (fake *FakeActor) RestartApplicationArgsForCall(i int) (string, bool) { fake.restartApplicationMutex.RLock() defer fake.restartApplicationMutex.RUnlock() argsForCall := fake.restartApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) RestartApplicationArgs() []FakeActorRestartApplicationArgs { + fake.restartApplicationMutex.RLock() + defer fake.restartApplicationMutex.RUnlock() + args := make([]FakeActorRestartApplicationArgs, len(fake.restartApplicationArgsForCall)) + copy(args, fake.restartApplicationArgsForCall) + return args } func (fake *FakeActor) RestartApplicationReturns(result1 v7action.Warnings, result2 error) { @@ -16793,8 +18838,7 @@ func (fake *FakeActor) RestartApplicationReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) RevokeAccessAndRefreshTokens() error { fake.revokeAccessAndRefreshTokensMutex.Lock() ret, specificReturn := fake.revokeAccessAndRefreshTokensReturnsOnCall[len(fake.revokeAccessAndRefreshTokensArgsForCall)] - fake.revokeAccessAndRefreshTokensArgsForCall = append(fake.revokeAccessAndRefreshTokensArgsForCall, struct { - }{}) + fake.revokeAccessAndRefreshTokensArgsForCall = append(fake.revokeAccessAndRefreshTokensArgsForCall, struct{}{}) stub := fake.RevokeAccessAndRefreshTokensStub fakeReturns := fake.revokeAccessAndRefreshTokensReturns fake.recordInvocation("RevokeAccessAndRefreshTokens", []interface{}{}) @@ -16846,10 +18890,7 @@ func (fake *FakeActor) RevokeAccessAndRefreshTokensReturnsOnCall(i int, result1 func (fake *FakeActor) RunTask(arg1 string, arg2 resources.Task) (resources.Task, v7action.Warnings, error) { fake.runTaskMutex.Lock() ret, specificReturn := fake.runTaskReturnsOnCall[len(fake.runTaskArgsForCall)] - fake.runTaskArgsForCall = append(fake.runTaskArgsForCall, struct { - arg1 string - arg2 resources.Task - }{arg1, arg2}) + fake.runTaskArgsForCall = append(fake.runTaskArgsForCall, FakeActorRunTaskArgs{arg1, arg2}) stub := fake.RunTaskStub fakeReturns := fake.runTaskReturns fake.recordInvocation("RunTask", []interface{}{arg1, arg2}) @@ -16879,7 +18920,15 @@ func (fake *FakeActor) RunTaskArgsForCall(i int) (string, resources.Task) { fake.runTaskMutex.RLock() defer fake.runTaskMutex.RUnlock() argsForCall := fake.runTaskArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) RunTaskArgs() []FakeActorRunTaskArgs { + fake.runTaskMutex.RLock() + defer fake.runTaskMutex.RUnlock() + args := make([]FakeActorRunTaskArgs, len(fake.runTaskArgsForCall)) + copy(args, fake.runTaskArgsForCall) + return args } func (fake *FakeActor) RunTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) { @@ -16914,10 +18963,7 @@ func (fake *FakeActor) RunTaskReturnsOnCall(i int, result1 resources.Task, resul func (fake *FakeActor) ScaleProcessByApplication(arg1 string, arg2 resources.Process) (v7action.Warnings, error) { fake.scaleProcessByApplicationMutex.Lock() ret, specificReturn := fake.scaleProcessByApplicationReturnsOnCall[len(fake.scaleProcessByApplicationArgsForCall)] - fake.scaleProcessByApplicationArgsForCall = append(fake.scaleProcessByApplicationArgsForCall, struct { - arg1 string - arg2 resources.Process - }{arg1, arg2}) + fake.scaleProcessByApplicationArgsForCall = append(fake.scaleProcessByApplicationArgsForCall, FakeActorScaleProcessByApplicationArgs{arg1, arg2}) stub := fake.ScaleProcessByApplicationStub fakeReturns := fake.scaleProcessByApplicationReturns fake.recordInvocation("ScaleProcessByApplication", []interface{}{arg1, arg2}) @@ -16947,7 +18993,15 @@ func (fake *FakeActor) ScaleProcessByApplicationArgsForCall(i int) (string, reso fake.scaleProcessByApplicationMutex.RLock() defer fake.scaleProcessByApplicationMutex.RUnlock() argsForCall := fake.scaleProcessByApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) ScaleProcessByApplicationArgs() []FakeActorScaleProcessByApplicationArgs { + fake.scaleProcessByApplicationMutex.RLock() + defer fake.scaleProcessByApplicationMutex.RUnlock() + args := make([]FakeActorScaleProcessByApplicationArgs, len(fake.scaleProcessByApplicationArgsForCall)) + copy(args, fake.scaleProcessByApplicationArgsForCall) + return args } func (fake *FakeActor) ScaleProcessByApplicationReturns(result1 v7action.Warnings, result2 error) { @@ -16979,11 +19033,7 @@ func (fake *FakeActor) ScaleProcessByApplicationReturnsOnCall(i int, result1 v7a func (fake *FakeActor) ScheduleTokenRefresh(arg1 func(time.Duration) <-chan time.Time, arg2 chan struct{}, arg3 chan struct{}) (<-chan error, error) { fake.scheduleTokenRefreshMutex.Lock() ret, specificReturn := fake.scheduleTokenRefreshReturnsOnCall[len(fake.scheduleTokenRefreshArgsForCall)] - fake.scheduleTokenRefreshArgsForCall = append(fake.scheduleTokenRefreshArgsForCall, struct { - arg1 func(time.Duration) <-chan time.Time - arg2 chan struct{} - arg3 chan struct{} - }{arg1, arg2, arg3}) + fake.scheduleTokenRefreshArgsForCall = append(fake.scheduleTokenRefreshArgsForCall, FakeActorScheduleTokenRefreshArgs{arg1, arg2, arg3}) stub := fake.ScheduleTokenRefreshStub fakeReturns := fake.scheduleTokenRefreshReturns fake.recordInvocation("ScheduleTokenRefresh", []interface{}{arg1, arg2, arg3}) @@ -17013,7 +19063,15 @@ func (fake *FakeActor) ScheduleTokenRefreshArgsForCall(i int) (func(time.Duratio fake.scheduleTokenRefreshMutex.RLock() defer fake.scheduleTokenRefreshMutex.RUnlock() argsForCall := fake.scheduleTokenRefreshArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) ScheduleTokenRefreshArgs() []FakeActorScheduleTokenRefreshArgs { + fake.scheduleTokenRefreshMutex.RLock() + defer fake.scheduleTokenRefreshMutex.RUnlock() + args := make([]FakeActorScheduleTokenRefreshArgs, len(fake.scheduleTokenRefreshArgsForCall)) + copy(args, fake.scheduleTokenRefreshArgsForCall) + return args } func (fake *FakeActor) ScheduleTokenRefreshReturns(result1 <-chan error, result2 error) { @@ -17045,10 +19103,7 @@ func (fake *FakeActor) ScheduleTokenRefreshReturnsOnCall(i int, result1 <-chan e func (fake *FakeActor) SetApplicationDroplet(arg1 string, arg2 string) (v7action.Warnings, error) { fake.setApplicationDropletMutex.Lock() ret, specificReturn := fake.setApplicationDropletReturnsOnCall[len(fake.setApplicationDropletArgsForCall)] - fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, FakeActorSetApplicationDropletArgs{arg1, arg2}) stub := fake.SetApplicationDropletStub fakeReturns := fake.setApplicationDropletReturns fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2}) @@ -17078,7 +19133,15 @@ func (fake *FakeActor) SetApplicationDropletArgsForCall(i int) (string, string) fake.setApplicationDropletMutex.RLock() defer fake.setApplicationDropletMutex.RUnlock() argsForCall := fake.setApplicationDropletArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SetApplicationDropletArgs() []FakeActorSetApplicationDropletArgs { + fake.setApplicationDropletMutex.RLock() + defer fake.setApplicationDropletMutex.RUnlock() + args := make([]FakeActorSetApplicationDropletArgs, len(fake.setApplicationDropletArgsForCall)) + copy(args, fake.setApplicationDropletArgsForCall) + return args } func (fake *FakeActor) SetApplicationDropletReturns(result1 v7action.Warnings, result2 error) { @@ -17110,11 +19173,7 @@ func (fake *FakeActor) SetApplicationDropletReturnsOnCall(i int, result1 v7actio func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.setApplicationDropletByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.setApplicationDropletByApplicationNameAndSpaceReturnsOnCall[len(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall)] - fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall = append(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall = append(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall, FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.SetApplicationDropletByApplicationNameAndSpaceStub fakeReturns := fake.setApplicationDropletByApplicationNameAndSpaceReturns fake.recordInvocation("SetApplicationDropletByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -17144,7 +19203,15 @@ func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceArgsForCall fake.setApplicationDropletByApplicationNameAndSpaceMutex.RLock() defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceArgs() []FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs { + fake.setApplicationDropletByApplicationNameAndSpaceMutex.RLock() + defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorSetApplicationDropletByApplicationNameAndSpaceArgs, len(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { @@ -17181,10 +19248,7 @@ func (fake *FakeActor) SetApplicationManifest(arg1 string, arg2 []byte) (v7actio } fake.setApplicationManifestMutex.Lock() ret, specificReturn := fake.setApplicationManifestReturnsOnCall[len(fake.setApplicationManifestArgsForCall)] - fake.setApplicationManifestArgsForCall = append(fake.setApplicationManifestArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.setApplicationManifestArgsForCall = append(fake.setApplicationManifestArgsForCall, FakeActorSetApplicationManifestArgs{arg1, arg2Copy}) stub := fake.SetApplicationManifestStub fakeReturns := fake.setApplicationManifestReturns fake.recordInvocation("SetApplicationManifest", []interface{}{arg1, arg2Copy}) @@ -17214,7 +19278,15 @@ func (fake *FakeActor) SetApplicationManifestArgsForCall(i int) (string, []byte) fake.setApplicationManifestMutex.RLock() defer fake.setApplicationManifestMutex.RUnlock() argsForCall := fake.setApplicationManifestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SetApplicationManifestArgs() []FakeActorSetApplicationManifestArgs { + fake.setApplicationManifestMutex.RLock() + defer fake.setApplicationManifestMutex.RUnlock() + args := make([]FakeActorSetApplicationManifestArgs, len(fake.setApplicationManifestArgsForCall)) + copy(args, fake.setApplicationManifestArgsForCall) + return args } func (fake *FakeActor) SetApplicationManifestReturns(result1 v7action.Warnings, result2 error) { @@ -17246,14 +19318,7 @@ func (fake *FakeActor) SetApplicationManifestReturnsOnCall(i int, result1 v7acti func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpace(arg1 string, arg2 string, arg3 constanta.HealthCheckType, arg4 string, arg5 string, arg6 int64) (resources.Application, v7action.Warnings, error) { fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Lock() ret, specificReturn := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall[len(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall)] - fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall = append(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 constanta.HealthCheckType - arg4 string - arg5 string - arg6 int64 - }{arg1, arg2, arg3, arg4, arg5, arg6}) + fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall = append(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall, FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs{arg1, arg2, arg3, arg4, arg5, arg6}) stub := fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub fakeReturns := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturns fake.recordInvocation("SetApplicationProcessHealthCheckTypeByNameAndSpace", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) @@ -17283,7 +19348,15 @@ func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceArgsFor fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RLock() defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RUnlock() argsForCall := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4, argsForCall.Arg5, argsForCall.Arg6 +} + +func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceArgs() []FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs { + fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RLock() + defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorSetApplicationProcessHealthCheckTypeByNameAndSpaceArgs, len(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall)) + copy(args, fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) { @@ -17318,11 +19391,7 @@ func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceReturns func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpace(arg1 string, arg2 string, arg3 v7action.EnvironmentVariablePair) (v7action.Warnings, error) { fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[len(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall)] - fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.EnvironmentVariablePair - }{arg1, arg2, arg3}) + fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall, FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.SetEnvironmentVariableByApplicationNameAndSpaceStub fakeReturns := fake.setEnvironmentVariableByApplicationNameAndSpaceReturns fake.recordInvocation("SetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -17352,7 +19421,15 @@ func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceArgsForCal fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RLock() defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceArgs() []FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs { + fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RLock() + defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorSetEnvironmentVariableByApplicationNameAndSpaceArgs, len(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { @@ -17384,10 +19461,7 @@ func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceReturnsOnC func (fake *FakeActor) SetEnvironmentVariableGroup(arg1 constanta.EnvironmentVariableGroupName, arg2 resources.EnvironmentVariables) (v7action.Warnings, error) { fake.setEnvironmentVariableGroupMutex.Lock() ret, specificReturn := fake.setEnvironmentVariableGroupReturnsOnCall[len(fake.setEnvironmentVariableGroupArgsForCall)] - fake.setEnvironmentVariableGroupArgsForCall = append(fake.setEnvironmentVariableGroupArgsForCall, struct { - arg1 constanta.EnvironmentVariableGroupName - arg2 resources.EnvironmentVariables - }{arg1, arg2}) + fake.setEnvironmentVariableGroupArgsForCall = append(fake.setEnvironmentVariableGroupArgsForCall, FakeActorSetEnvironmentVariableGroupArgs{arg1, arg2}) stub := fake.SetEnvironmentVariableGroupStub fakeReturns := fake.setEnvironmentVariableGroupReturns fake.recordInvocation("SetEnvironmentVariableGroup", []interface{}{arg1, arg2}) @@ -17417,7 +19491,15 @@ func (fake *FakeActor) SetEnvironmentVariableGroupArgsForCall(i int) (constanta. fake.setEnvironmentVariableGroupMutex.RLock() defer fake.setEnvironmentVariableGroupMutex.RUnlock() argsForCall := fake.setEnvironmentVariableGroupArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SetEnvironmentVariableGroupArgs() []FakeActorSetEnvironmentVariableGroupArgs { + fake.setEnvironmentVariableGroupMutex.RLock() + defer fake.setEnvironmentVariableGroupMutex.RUnlock() + args := make([]FakeActorSetEnvironmentVariableGroupArgs, len(fake.setEnvironmentVariableGroupArgsForCall)) + copy(args, fake.setEnvironmentVariableGroupArgsForCall) + return args } func (fake *FakeActor) SetEnvironmentVariableGroupReturns(result1 v7action.Warnings, result2 error) { @@ -17449,10 +19531,7 @@ func (fake *FakeActor) SetEnvironmentVariableGroupReturnsOnCall(i int, result1 v func (fake *FakeActor) SetOrganizationDefaultIsolationSegment(arg1 string, arg2 string) (v7action.Warnings, error) { fake.setOrganizationDefaultIsolationSegmentMutex.Lock() ret, specificReturn := fake.setOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.setOrganizationDefaultIsolationSegmentArgsForCall)] - fake.setOrganizationDefaultIsolationSegmentArgsForCall = append(fake.setOrganizationDefaultIsolationSegmentArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.setOrganizationDefaultIsolationSegmentArgsForCall = append(fake.setOrganizationDefaultIsolationSegmentArgsForCall, FakeActorSetOrganizationDefaultIsolationSegmentArgs{arg1, arg2}) stub := fake.SetOrganizationDefaultIsolationSegmentStub fakeReturns := fake.setOrganizationDefaultIsolationSegmentReturns fake.recordInvocation("SetOrganizationDefaultIsolationSegment", []interface{}{arg1, arg2}) @@ -17466,46 +19545,124 @@ func (fake *FakeActor) SetOrganizationDefaultIsolationSegment(arg1 string, arg2 return fakeReturns.result1, fakeReturns.result2 } -func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCallCount() int { - fake.setOrganizationDefaultIsolationSegmentMutex.RLock() - defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock() - return len(fake.setOrganizationDefaultIsolationSegmentArgsForCall) +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCallCount() int { + fake.setOrganizationDefaultIsolationSegmentMutex.RLock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock() + return len(fake.setOrganizationDefaultIsolationSegmentArgsForCall) +} + +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCalls(stub func(string, string) (v7action.Warnings, error)) { + fake.setOrganizationDefaultIsolationSegmentMutex.Lock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() + fake.SetOrganizationDefaultIsolationSegmentStub = stub +} + +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentArgsForCall(i int) (string, string) { + fake.setOrganizationDefaultIsolationSegmentMutex.RLock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock() + argsForCall := fake.setOrganizationDefaultIsolationSegmentArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentArgs() []FakeActorSetOrganizationDefaultIsolationSegmentArgs { + fake.setOrganizationDefaultIsolationSegmentMutex.RLock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock() + args := make([]FakeActorSetOrganizationDefaultIsolationSegmentArgs, len(fake.setOrganizationDefaultIsolationSegmentArgsForCall)) + copy(args, fake.setOrganizationDefaultIsolationSegmentArgsForCall) + return args +} + +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturns(result1 v7action.Warnings, result2 error) { + fake.setOrganizationDefaultIsolationSegmentMutex.Lock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() + fake.SetOrganizationDefaultIsolationSegmentStub = nil + fake.setOrganizationDefaultIsolationSegmentReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.setOrganizationDefaultIsolationSegmentMutex.Lock() + defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() + fake.SetOrganizationDefaultIsolationSegmentStub = nil + if fake.setOrganizationDefaultIsolationSegmentReturnsOnCall == nil { + fake.setOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.setOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpace(arg1 string, arg2 string, arg3 bool) (v7action.Warnings, error) { + fake.setServiceAccountEnabledByNameAndSpaceMutex.Lock() + ret, specificReturn := fake.setServiceAccountEnabledByNameAndSpaceReturnsOnCall[len(fake.setServiceAccountEnabledByNameAndSpaceArgsForCall)] + fake.setServiceAccountEnabledByNameAndSpaceArgsForCall = append(fake.setServiceAccountEnabledByNameAndSpaceArgsForCall, FakeActorSetServiceAccountEnabledByNameAndSpaceArgs{arg1, arg2, arg3}) + stub := fake.SetServiceAccountEnabledByNameAndSpaceStub + fakeReturns := fake.setServiceAccountEnabledByNameAndSpaceReturns + fake.recordInvocation("SetServiceAccountEnabledByNameAndSpace", []interface{}{arg1, arg2, arg3}) + fake.setServiceAccountEnabledByNameAndSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceCallCount() int { + fake.setServiceAccountEnabledByNameAndSpaceMutex.RLock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.RUnlock() + return len(fake.setServiceAccountEnabledByNameAndSpaceArgsForCall) +} + +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceCalls(stub func(string, string, bool) (v7action.Warnings, error)) { + fake.setServiceAccountEnabledByNameAndSpaceMutex.Lock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.Unlock() + fake.SetServiceAccountEnabledByNameAndSpaceStub = stub } -func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCalls(stub func(string, string) (v7action.Warnings, error)) { - fake.setOrganizationDefaultIsolationSegmentMutex.Lock() - defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() - fake.SetOrganizationDefaultIsolationSegmentStub = stub +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceArgsForCall(i int) (string, string, bool) { + fake.setServiceAccountEnabledByNameAndSpaceMutex.RLock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.RUnlock() + argsForCall := fake.setServiceAccountEnabledByNameAndSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 } -func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentArgsForCall(i int) (string, string) { - fake.setOrganizationDefaultIsolationSegmentMutex.RLock() - defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock() - argsForCall := fake.setOrganizationDefaultIsolationSegmentArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceArgs() []FakeActorSetServiceAccountEnabledByNameAndSpaceArgs { + fake.setServiceAccountEnabledByNameAndSpaceMutex.RLock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.RUnlock() + args := make([]FakeActorSetServiceAccountEnabledByNameAndSpaceArgs, len(fake.setServiceAccountEnabledByNameAndSpaceArgsForCall)) + copy(args, fake.setServiceAccountEnabledByNameAndSpaceArgsForCall) + return args } -func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturns(result1 v7action.Warnings, result2 error) { - fake.setOrganizationDefaultIsolationSegmentMutex.Lock() - defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() - fake.SetOrganizationDefaultIsolationSegmentStub = nil - fake.setOrganizationDefaultIsolationSegmentReturns = struct { +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { + fake.setServiceAccountEnabledByNameAndSpaceMutex.Lock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.Unlock() + fake.SetServiceAccountEnabledByNameAndSpaceStub = nil + fake.setServiceAccountEnabledByNameAndSpaceReturns = struct { result1 v7action.Warnings result2 error }{result1, result2} } -func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { - fake.setOrganizationDefaultIsolationSegmentMutex.Lock() - defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock() - fake.SetOrganizationDefaultIsolationSegmentStub = nil - if fake.setOrganizationDefaultIsolationSegmentReturnsOnCall == nil { - fake.setOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct { +func (fake *FakeActor) SetServiceAccountEnabledByNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.setServiceAccountEnabledByNameAndSpaceMutex.Lock() + defer fake.setServiceAccountEnabledByNameAndSpaceMutex.Unlock() + fake.SetServiceAccountEnabledByNameAndSpaceStub = nil + if fake.setServiceAccountEnabledByNameAndSpaceReturnsOnCall == nil { + fake.setServiceAccountEnabledByNameAndSpaceReturnsOnCall = make(map[int]struct { result1 v7action.Warnings result2 error }) } - fake.setOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct { + fake.setServiceAccountEnabledByNameAndSpaceReturnsOnCall[i] = struct { result1 v7action.Warnings result2 error }{result1, result2} @@ -17519,10 +19676,7 @@ func (fake *FakeActor) SetSpaceManifest(arg1 string, arg2 []byte) (v7action.Warn } fake.setSpaceManifestMutex.Lock() ret, specificReturn := fake.setSpaceManifestReturnsOnCall[len(fake.setSpaceManifestArgsForCall)] - fake.setSpaceManifestArgsForCall = append(fake.setSpaceManifestArgsForCall, struct { - arg1 string - arg2 []byte - }{arg1, arg2Copy}) + fake.setSpaceManifestArgsForCall = append(fake.setSpaceManifestArgsForCall, FakeActorSetSpaceManifestArgs{arg1, arg2Copy}) stub := fake.SetSpaceManifestStub fakeReturns := fake.setSpaceManifestReturns fake.recordInvocation("SetSpaceManifest", []interface{}{arg1, arg2Copy}) @@ -17552,7 +19706,15 @@ func (fake *FakeActor) SetSpaceManifestArgsForCall(i int) (string, []byte) { fake.setSpaceManifestMutex.RLock() defer fake.setSpaceManifestMutex.RUnlock() argsForCall := fake.setSpaceManifestArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SetSpaceManifestArgs() []FakeActorSetSpaceManifestArgs { + fake.setSpaceManifestMutex.RLock() + defer fake.setSpaceManifestMutex.RUnlock() + args := make([]FakeActorSetSpaceManifestArgs, len(fake.setSpaceManifestArgsForCall)) + copy(args, fake.setSpaceManifestArgsForCall) + return args } func (fake *FakeActor) SetSpaceManifestReturns(result1 v7action.Warnings, result2 error) { @@ -17584,9 +19746,7 @@ func (fake *FakeActor) SetSpaceManifestReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) SetTarget(arg1 v7action.TargetSettings) (v7action.Warnings, error) { fake.setTargetMutex.Lock() ret, specificReturn := fake.setTargetReturnsOnCall[len(fake.setTargetArgsForCall)] - fake.setTargetArgsForCall = append(fake.setTargetArgsForCall, struct { - arg1 v7action.TargetSettings - }{arg1}) + fake.setTargetArgsForCall = append(fake.setTargetArgsForCall, FakeActorSetTargetArgs{arg1}) stub := fake.SetTargetStub fakeReturns := fake.setTargetReturns fake.recordInvocation("SetTarget", []interface{}{arg1}) @@ -17616,7 +19776,15 @@ func (fake *FakeActor) SetTargetArgsForCall(i int) v7action.TargetSettings { fake.setTargetMutex.RLock() defer fake.setTargetMutex.RUnlock() argsForCall := fake.setTargetArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) SetTargetArgs() []FakeActorSetTargetArgs { + fake.setTargetMutex.RLock() + defer fake.setTargetMutex.RUnlock() + args := make([]FakeActorSetTargetArgs, len(fake.setTargetArgsForCall)) + copy(args, fake.setTargetArgsForCall) + return args } func (fake *FakeActor) SetTargetReturns(result1 v7action.Warnings, result2 error) { @@ -17648,10 +19816,7 @@ func (fake *FakeActor) SetTargetReturnsOnCall(i int, result1 v7action.Warnings, func (fake *FakeActor) SharePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) { fake.sharePrivateDomainMutex.Lock() ret, specificReturn := fake.sharePrivateDomainReturnsOnCall[len(fake.sharePrivateDomainArgsForCall)] - fake.sharePrivateDomainArgsForCall = append(fake.sharePrivateDomainArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.sharePrivateDomainArgsForCall = append(fake.sharePrivateDomainArgsForCall, FakeActorSharePrivateDomainArgs{arg1, arg2}) stub := fake.SharePrivateDomainStub fakeReturns := fake.sharePrivateDomainReturns fake.recordInvocation("SharePrivateDomain", []interface{}{arg1, arg2}) @@ -17681,7 +19846,15 @@ func (fake *FakeActor) SharePrivateDomainArgsForCall(i int) (string, string) { fake.sharePrivateDomainMutex.RLock() defer fake.sharePrivateDomainMutex.RUnlock() argsForCall := fake.sharePrivateDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) SharePrivateDomainArgs() []FakeActorSharePrivateDomainArgs { + fake.sharePrivateDomainMutex.RLock() + defer fake.sharePrivateDomainMutex.RUnlock() + args := make([]FakeActorSharePrivateDomainArgs, len(fake.sharePrivateDomainArgsForCall)) + copy(args, fake.sharePrivateDomainArgsForCall) + return args } func (fake *FakeActor) SharePrivateDomainReturns(result1 v7action.Warnings, result2 error) { @@ -17713,10 +19886,7 @@ func (fake *FakeActor) SharePrivateDomainReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) ShareRoute(arg1 string, arg2 string) (v7action.Warnings, error) { fake.shareRouteMutex.Lock() ret, specificReturn := fake.shareRouteReturnsOnCall[len(fake.shareRouteArgsForCall)] - fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, FakeActorShareRouteArgs{arg1, arg2}) stub := fake.ShareRouteStub fakeReturns := fake.shareRouteReturns fake.recordInvocation("ShareRoute", []interface{}{arg1, arg2}) @@ -17746,7 +19916,15 @@ func (fake *FakeActor) ShareRouteArgsForCall(i int) (string, string) { fake.shareRouteMutex.RLock() defer fake.shareRouteMutex.RUnlock() argsForCall := fake.shareRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) ShareRouteArgs() []FakeActorShareRouteArgs { + fake.shareRouteMutex.RLock() + defer fake.shareRouteMutex.RUnlock() + args := make([]FakeActorShareRouteArgs, len(fake.shareRouteArgsForCall)) + copy(args, fake.shareRouteArgsForCall) + return args } func (fake *FakeActor) ShareRouteReturns(result1 v7action.Warnings, result2 error) { @@ -17778,12 +19956,7 @@ func (fake *FakeActor) ShareRouteReturnsOnCall(i int, result1 v7action.Warnings, func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrg(arg1 string, arg2 string, arg3 string, arg4 v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) { fake.shareServiceInstanceToSpaceAndOrgMutex.Lock() ret, specificReturn := fake.shareServiceInstanceToSpaceAndOrgReturnsOnCall[len(fake.shareServiceInstanceToSpaceAndOrgArgsForCall)] - fake.shareServiceInstanceToSpaceAndOrgArgsForCall = append(fake.shareServiceInstanceToSpaceAndOrgArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.ServiceInstanceSharingParams - }{arg1, arg2, arg3, arg4}) + fake.shareServiceInstanceToSpaceAndOrgArgsForCall = append(fake.shareServiceInstanceToSpaceAndOrgArgsForCall, FakeActorShareServiceInstanceToSpaceAndOrgArgs{arg1, arg2, arg3, arg4}) stub := fake.ShareServiceInstanceToSpaceAndOrgStub fakeReturns := fake.shareServiceInstanceToSpaceAndOrgReturns fake.recordInvocation("ShareServiceInstanceToSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4}) @@ -17813,7 +19986,15 @@ func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgArgsForCall(i int) (stri fake.shareServiceInstanceToSpaceAndOrgMutex.RLock() defer fake.shareServiceInstanceToSpaceAndOrgMutex.RUnlock() argsForCall := fake.shareServiceInstanceToSpaceAndOrgArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgArgs() []FakeActorShareServiceInstanceToSpaceAndOrgArgs { + fake.shareServiceInstanceToSpaceAndOrgMutex.RLock() + defer fake.shareServiceInstanceToSpaceAndOrgMutex.RUnlock() + args := make([]FakeActorShareServiceInstanceToSpaceAndOrgArgs, len(fake.shareServiceInstanceToSpaceAndOrgArgsForCall)) + copy(args, fake.shareServiceInstanceToSpaceAndOrgArgsForCall) + return args } func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgReturns(result1 v7action.Warnings, result2 error) { @@ -17845,9 +20026,7 @@ func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgReturnsOnCall(i int, res func (fake *FakeActor) StageApplicationPackage(arg1 string) (resources.Build, v7action.Warnings, error) { fake.stageApplicationPackageMutex.Lock() ret, specificReturn := fake.stageApplicationPackageReturnsOnCall[len(fake.stageApplicationPackageArgsForCall)] - fake.stageApplicationPackageArgsForCall = append(fake.stageApplicationPackageArgsForCall, struct { - arg1 string - }{arg1}) + fake.stageApplicationPackageArgsForCall = append(fake.stageApplicationPackageArgsForCall, FakeActorStageApplicationPackageArgs{arg1}) stub := fake.StageApplicationPackageStub fakeReturns := fake.stageApplicationPackageReturns fake.recordInvocation("StageApplicationPackage", []interface{}{arg1}) @@ -17877,7 +20056,15 @@ func (fake *FakeActor) StageApplicationPackageArgsForCall(i int) string { fake.stageApplicationPackageMutex.RLock() defer fake.stageApplicationPackageMutex.RUnlock() argsForCall := fake.stageApplicationPackageArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) StageApplicationPackageArgs() []FakeActorStageApplicationPackageArgs { + fake.stageApplicationPackageMutex.RLock() + defer fake.stageApplicationPackageMutex.RUnlock() + args := make([]FakeActorStageApplicationPackageArgs, len(fake.stageApplicationPackageArgsForCall)) + copy(args, fake.stageApplicationPackageArgsForCall) + return args } func (fake *FakeActor) StageApplicationPackageReturns(result1 resources.Build, result2 v7action.Warnings, result3 error) { @@ -17912,11 +20099,7 @@ func (fake *FakeActor) StageApplicationPackageReturnsOnCall(i int, result1 resou func (fake *FakeActor) StagePackage(arg1 string, arg2 string, arg3 string) (<-chan resources.Droplet, <-chan v7action.Warnings, <-chan error) { fake.stagePackageMutex.Lock() ret, specificReturn := fake.stagePackageReturnsOnCall[len(fake.stagePackageArgsForCall)] - fake.stagePackageArgsForCall = append(fake.stagePackageArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.stagePackageArgsForCall = append(fake.stagePackageArgsForCall, FakeActorStagePackageArgs{arg1, arg2, arg3}) stub := fake.StagePackageStub fakeReturns := fake.stagePackageReturns fake.recordInvocation("StagePackage", []interface{}{arg1, arg2, arg3}) @@ -17946,7 +20129,15 @@ func (fake *FakeActor) StagePackageArgsForCall(i int) (string, string, string) { fake.stagePackageMutex.RLock() defer fake.stagePackageMutex.RUnlock() argsForCall := fake.stagePackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) StagePackageArgs() []FakeActorStagePackageArgs { + fake.stagePackageMutex.RLock() + defer fake.stagePackageMutex.RUnlock() + args := make([]FakeActorStagePackageArgs, len(fake.stagePackageArgsForCall)) + copy(args, fake.stagePackageArgsForCall) + return args } func (fake *FakeActor) StagePackageReturns(result1 <-chan resources.Droplet, result2 <-chan v7action.Warnings, result3 <-chan error) { @@ -17981,9 +20172,7 @@ func (fake *FakeActor) StagePackageReturnsOnCall(i int, result1 <-chan resources func (fake *FakeActor) StartApplication(arg1 string) (v7action.Warnings, error) { fake.startApplicationMutex.Lock() ret, specificReturn := fake.startApplicationReturnsOnCall[len(fake.startApplicationArgsForCall)] - fake.startApplicationArgsForCall = append(fake.startApplicationArgsForCall, struct { - arg1 string - }{arg1}) + fake.startApplicationArgsForCall = append(fake.startApplicationArgsForCall, FakeActorStartApplicationArgs{arg1}) stub := fake.StartApplicationStub fakeReturns := fake.startApplicationReturns fake.recordInvocation("StartApplication", []interface{}{arg1}) @@ -18013,7 +20202,15 @@ func (fake *FakeActor) StartApplicationArgsForCall(i int) string { fake.startApplicationMutex.RLock() defer fake.startApplicationMutex.RUnlock() argsForCall := fake.startApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) StartApplicationArgs() []FakeActorStartApplicationArgs { + fake.startApplicationMutex.RLock() + defer fake.startApplicationMutex.RUnlock() + args := make([]FakeActorStartApplicationArgs, len(fake.startApplicationArgsForCall)) + copy(args, fake.startApplicationArgsForCall) + return args } func (fake *FakeActor) StartApplicationReturns(result1 v7action.Warnings, result2 error) { @@ -18045,9 +20242,7 @@ func (fake *FakeActor) StartApplicationReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) StopApplication(arg1 string) (v7action.Warnings, error) { fake.stopApplicationMutex.Lock() ret, specificReturn := fake.stopApplicationReturnsOnCall[len(fake.stopApplicationArgsForCall)] - fake.stopApplicationArgsForCall = append(fake.stopApplicationArgsForCall, struct { - arg1 string - }{arg1}) + fake.stopApplicationArgsForCall = append(fake.stopApplicationArgsForCall, FakeActorStopApplicationArgs{arg1}) stub := fake.StopApplicationStub fakeReturns := fake.stopApplicationReturns fake.recordInvocation("StopApplication", []interface{}{arg1}) @@ -18077,7 +20272,15 @@ func (fake *FakeActor) StopApplicationArgsForCall(i int) string { fake.stopApplicationMutex.RLock() defer fake.stopApplicationMutex.RUnlock() argsForCall := fake.stopApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) StopApplicationArgs() []FakeActorStopApplicationArgs { + fake.stopApplicationMutex.RLock() + defer fake.stopApplicationMutex.RUnlock() + args := make([]FakeActorStopApplicationArgs, len(fake.stopApplicationArgsForCall)) + copy(args, fake.stopApplicationArgsForCall) + return args } func (fake *FakeActor) StopApplicationReturns(result1 v7action.Warnings, result2 error) { @@ -18109,9 +20312,7 @@ func (fake *FakeActor) StopApplicationReturnsOnCall(i int, result1 v7action.Warn func (fake *FakeActor) TerminateTask(arg1 string) (resources.Task, v7action.Warnings, error) { fake.terminateTaskMutex.Lock() ret, specificReturn := fake.terminateTaskReturnsOnCall[len(fake.terminateTaskArgsForCall)] - fake.terminateTaskArgsForCall = append(fake.terminateTaskArgsForCall, struct { - arg1 string - }{arg1}) + fake.terminateTaskArgsForCall = append(fake.terminateTaskArgsForCall, FakeActorTerminateTaskArgs{arg1}) stub := fake.TerminateTaskStub fakeReturns := fake.terminateTaskReturns fake.recordInvocation("TerminateTask", []interface{}{arg1}) @@ -18141,7 +20342,15 @@ func (fake *FakeActor) TerminateTaskArgsForCall(i int) string { fake.terminateTaskMutex.RLock() defer fake.terminateTaskMutex.RUnlock() argsForCall := fake.terminateTaskArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) TerminateTaskArgs() []FakeActorTerminateTaskArgs { + fake.terminateTaskMutex.RLock() + defer fake.terminateTaskMutex.RUnlock() + args := make([]FakeActorTerminateTaskArgs, len(fake.terminateTaskArgsForCall)) + copy(args, fake.terminateTaskArgsForCall) + return args } func (fake *FakeActor) TerminateTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) { @@ -18176,12 +20385,7 @@ func (fake *FakeActor) TerminateTaskReturnsOnCall(i int, result1 resources.Task, func (fake *FakeActor) UnbindSecurityGroup(arg1 string, arg2 string, arg3 string, arg4 constanta.SecurityGroupLifecycle) (v7action.Warnings, error) { fake.unbindSecurityGroupMutex.Lock() ret, specificReturn := fake.unbindSecurityGroupReturnsOnCall[len(fake.unbindSecurityGroupArgsForCall)] - fake.unbindSecurityGroupArgsForCall = append(fake.unbindSecurityGroupArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 constanta.SecurityGroupLifecycle - }{arg1, arg2, arg3, arg4}) + fake.unbindSecurityGroupArgsForCall = append(fake.unbindSecurityGroupArgsForCall, FakeActorUnbindSecurityGroupArgs{arg1, arg2, arg3, arg4}) stub := fake.UnbindSecurityGroupStub fakeReturns := fake.unbindSecurityGroupReturns fake.recordInvocation("UnbindSecurityGroup", []interface{}{arg1, arg2, arg3, arg4}) @@ -18211,7 +20415,15 @@ func (fake *FakeActor) UnbindSecurityGroupArgsForCall(i int) (string, string, st fake.unbindSecurityGroupMutex.RLock() defer fake.unbindSecurityGroupMutex.RUnlock() argsForCall := fake.unbindSecurityGroupArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UnbindSecurityGroupArgs() []FakeActorUnbindSecurityGroupArgs { + fake.unbindSecurityGroupMutex.RLock() + defer fake.unbindSecurityGroupMutex.RUnlock() + args := make([]FakeActorUnbindSecurityGroupArgs, len(fake.unbindSecurityGroupArgsForCall)) + copy(args, fake.unbindSecurityGroupArgsForCall) + return args } func (fake *FakeActor) UnbindSecurityGroupReturns(result1 v7action.Warnings, result2 error) { @@ -18240,13 +20452,80 @@ func (fake *FakeActor) UnbindSecurityGroupReturnsOnCall(i int, result1 v7action. }{result1, result2} } +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpace(arg1 string, arg2 string) (v7action.Warnings, error) { + fake.unbindServiceAccountByAppNameAndSpaceMutex.Lock() + ret, specificReturn := fake.unbindServiceAccountByAppNameAndSpaceReturnsOnCall[len(fake.unbindServiceAccountByAppNameAndSpaceArgsForCall)] + fake.unbindServiceAccountByAppNameAndSpaceArgsForCall = append(fake.unbindServiceAccountByAppNameAndSpaceArgsForCall, FakeActorUnbindServiceAccountByAppNameAndSpaceArgs{arg1, arg2}) + stub := fake.UnbindServiceAccountByAppNameAndSpaceStub + fakeReturns := fake.unbindServiceAccountByAppNameAndSpaceReturns + fake.recordInvocation("UnbindServiceAccountByAppNameAndSpace", []interface{}{arg1, arg2}) + fake.unbindServiceAccountByAppNameAndSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceCallCount() int { + fake.unbindServiceAccountByAppNameAndSpaceMutex.RLock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.RUnlock() + return len(fake.unbindServiceAccountByAppNameAndSpaceArgsForCall) +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceCalls(stub func(string, string) (v7action.Warnings, error)) { + fake.unbindServiceAccountByAppNameAndSpaceMutex.Lock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.Unlock() + fake.UnbindServiceAccountByAppNameAndSpaceStub = stub +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceArgsForCall(i int) (string, string) { + fake.unbindServiceAccountByAppNameAndSpaceMutex.RLock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.RUnlock() + argsForCall := fake.unbindServiceAccountByAppNameAndSpaceArgsForCall[i] + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceArgs() []FakeActorUnbindServiceAccountByAppNameAndSpaceArgs { + fake.unbindServiceAccountByAppNameAndSpaceMutex.RLock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.RUnlock() + args := make([]FakeActorUnbindServiceAccountByAppNameAndSpaceArgs, len(fake.unbindServiceAccountByAppNameAndSpaceArgsForCall)) + copy(args, fake.unbindServiceAccountByAppNameAndSpaceArgsForCall) + return args +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { + fake.unbindServiceAccountByAppNameAndSpaceMutex.Lock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.Unlock() + fake.UnbindServiceAccountByAppNameAndSpaceStub = nil + fake.unbindServiceAccountByAppNameAndSpaceReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) UnbindServiceAccountByAppNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.unbindServiceAccountByAppNameAndSpaceMutex.Lock() + defer fake.unbindServiceAccountByAppNameAndSpaceMutex.Unlock() + fake.UnbindServiceAccountByAppNameAndSpaceStub = nil + if fake.unbindServiceAccountByAppNameAndSpaceReturnsOnCall == nil { + fake.unbindServiceAccountByAppNameAndSpaceReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.unbindServiceAccountByAppNameAndSpaceReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + func (fake *FakeActor) UnmapRoute(arg1 string, arg2 string) (v7action.Warnings, error) { fake.unmapRouteMutex.Lock() ret, specificReturn := fake.unmapRouteReturnsOnCall[len(fake.unmapRouteArgsForCall)] - fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, FakeActorUnmapRouteArgs{arg1, arg2}) stub := fake.UnmapRouteStub fakeReturns := fake.unmapRouteReturns fake.recordInvocation("UnmapRoute", []interface{}{arg1, arg2}) @@ -18276,7 +20555,15 @@ func (fake *FakeActor) UnmapRouteArgsForCall(i int) (string, string) { fake.unmapRouteMutex.RLock() defer fake.unmapRouteMutex.RUnlock() argsForCall := fake.unmapRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UnmapRouteArgs() []FakeActorUnmapRouteArgs { + fake.unmapRouteMutex.RLock() + defer fake.unmapRouteMutex.RUnlock() + args := make([]FakeActorUnmapRouteArgs, len(fake.unmapRouteArgsForCall)) + copy(args, fake.unmapRouteArgsForCall) + return args } func (fake *FakeActor) UnmapRouteReturns(result1 v7action.Warnings, result2 error) { @@ -18308,11 +20595,7 @@ func (fake *FakeActor) UnmapRouteReturnsOnCall(i int, result1 v7action.Warnings, func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Lock() ret, specificReturn := fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[len(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall)] - fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall, FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs{arg1, arg2, arg3}) stub := fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub fakeReturns := fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturns fake.recordInvocation("UnsetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3}) @@ -18342,7 +20625,15 @@ func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceArgsForC fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RLock() defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock() argsForCall := fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceArgs() []FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs { + fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RLock() + defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock() + args := make([]FakeActorUnsetEnvironmentVariableByApplicationNameAndSpaceArgs, len(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall)) + copy(args, fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall) + return args } func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) { @@ -18374,11 +20665,7 @@ func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceReturnsO func (fake *FakeActor) UnsetSpaceQuota(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.unsetSpaceQuotaMutex.Lock() ret, specificReturn := fake.unsetSpaceQuotaReturnsOnCall[len(fake.unsetSpaceQuotaArgsForCall)] - fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, FakeActorUnsetSpaceQuotaArgs{arg1, arg2, arg3}) stub := fake.UnsetSpaceQuotaStub fakeReturns := fake.unsetSpaceQuotaReturns fake.recordInvocation("UnsetSpaceQuota", []interface{}{arg1, arg2, arg3}) @@ -18408,7 +20695,15 @@ func (fake *FakeActor) UnsetSpaceQuotaArgsForCall(i int) (string, string, string fake.unsetSpaceQuotaMutex.RLock() defer fake.unsetSpaceQuotaMutex.RUnlock() argsForCall := fake.unsetSpaceQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UnsetSpaceQuotaArgs() []FakeActorUnsetSpaceQuotaArgs { + fake.unsetSpaceQuotaMutex.RLock() + defer fake.unsetSpaceQuotaMutex.RUnlock() + args := make([]FakeActorUnsetSpaceQuotaArgs, len(fake.unsetSpaceQuotaArgsForCall)) + copy(args, fake.unsetSpaceQuotaArgsForCall) + return args } func (fake *FakeActor) UnsetSpaceQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -18440,10 +20735,7 @@ func (fake *FakeActor) UnsetSpaceQuotaReturnsOnCall(i int, result1 v7action.Warn func (fake *FakeActor) UnsharePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) { fake.unsharePrivateDomainMutex.Lock() ret, specificReturn := fake.unsharePrivateDomainReturnsOnCall[len(fake.unsharePrivateDomainArgsForCall)] - fake.unsharePrivateDomainArgsForCall = append(fake.unsharePrivateDomainArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unsharePrivateDomainArgsForCall = append(fake.unsharePrivateDomainArgsForCall, FakeActorUnsharePrivateDomainArgs{arg1, arg2}) stub := fake.UnsharePrivateDomainStub fakeReturns := fake.unsharePrivateDomainReturns fake.recordInvocation("UnsharePrivateDomain", []interface{}{arg1, arg2}) @@ -18473,7 +20765,15 @@ func (fake *FakeActor) UnsharePrivateDomainArgsForCall(i int) (string, string) { fake.unsharePrivateDomainMutex.RLock() defer fake.unsharePrivateDomainMutex.RUnlock() argsForCall := fake.unsharePrivateDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UnsharePrivateDomainArgs() []FakeActorUnsharePrivateDomainArgs { + fake.unsharePrivateDomainMutex.RLock() + defer fake.unsharePrivateDomainMutex.RUnlock() + args := make([]FakeActorUnsharePrivateDomainArgs, len(fake.unsharePrivateDomainArgsForCall)) + copy(args, fake.unsharePrivateDomainArgsForCall) + return args } func (fake *FakeActor) UnsharePrivateDomainReturns(result1 v7action.Warnings, result2 error) { @@ -18505,10 +20805,7 @@ func (fake *FakeActor) UnsharePrivateDomainReturnsOnCall(i int, result1 v7action func (fake *FakeActor) UnshareRoute(arg1 string, arg2 string) (v7action.Warnings, error) { fake.unshareRouteMutex.Lock() ret, specificReturn := fake.unshareRouteReturnsOnCall[len(fake.unshareRouteArgsForCall)] - fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, FakeActorUnshareRouteArgs{arg1, arg2}) stub := fake.UnshareRouteStub fakeReturns := fake.unshareRouteReturns fake.recordInvocation("UnshareRoute", []interface{}{arg1, arg2}) @@ -18538,7 +20835,15 @@ func (fake *FakeActor) UnshareRouteArgsForCall(i int) (string, string) { fake.unshareRouteMutex.RLock() defer fake.unshareRouteMutex.RUnlock() argsForCall := fake.unshareRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UnshareRouteArgs() []FakeActorUnshareRouteArgs { + fake.unshareRouteMutex.RLock() + defer fake.unshareRouteMutex.RUnlock() + args := make([]FakeActorUnshareRouteArgs, len(fake.unshareRouteArgsForCall)) + copy(args, fake.unshareRouteArgsForCall) + return args } func (fake *FakeActor) UnshareRouteReturns(result1 v7action.Warnings, result2 error) { @@ -18570,12 +20875,7 @@ func (fake *FakeActor) UnshareRouteReturnsOnCall(i int, result1 v7action.Warning func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrg(arg1 string, arg2 string, arg3 string, arg4 v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) { fake.unshareServiceInstanceFromSpaceAndOrgMutex.Lock() ret, specificReturn := fake.unshareServiceInstanceFromSpaceAndOrgReturnsOnCall[len(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall)] - fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall = append(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.ServiceInstanceSharingParams - }{arg1, arg2, arg3, arg4}) + fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall = append(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall, FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs{arg1, arg2, arg3, arg4}) stub := fake.UnshareServiceInstanceFromSpaceAndOrgStub fakeReturns := fake.unshareServiceInstanceFromSpaceAndOrgReturns fake.recordInvocation("UnshareServiceInstanceFromSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4}) @@ -18605,7 +20905,15 @@ func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgArgsForCall(i int) ( fake.unshareServiceInstanceFromSpaceAndOrgMutex.RLock() defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.RUnlock() argsForCall := fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgArgs() []FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs { + fake.unshareServiceInstanceFromSpaceAndOrgMutex.RLock() + defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.RUnlock() + args := make([]FakeActorUnshareServiceInstanceFromSpaceAndOrgArgs, len(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall)) + copy(args, fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall) + return args } func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgReturns(result1 v7action.Warnings, result2 error) { @@ -18637,11 +20945,7 @@ func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgReturnsOnCall(i int, func (fake *FakeActor) UpdateAppFeature(arg1 resources.Application, arg2 bool, arg3 string) (v7action.Warnings, error) { fake.updateAppFeatureMutex.Lock() ret, specificReturn := fake.updateAppFeatureReturnsOnCall[len(fake.updateAppFeatureArgsForCall)] - fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, struct { - arg1 resources.Application - arg2 bool - arg3 string - }{arg1, arg2, arg3}) + fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, FakeActorUpdateAppFeatureArgs{arg1, arg2, arg3}) stub := fake.UpdateAppFeatureStub fakeReturns := fake.updateAppFeatureReturns fake.recordInvocation("UpdateAppFeature", []interface{}{arg1, arg2, arg3}) @@ -18671,7 +20975,15 @@ func (fake *FakeActor) UpdateAppFeatureArgsForCall(i int) (resources.Application fake.updateAppFeatureMutex.RLock() defer fake.updateAppFeatureMutex.RUnlock() argsForCall := fake.updateAppFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateAppFeatureArgs() []FakeActorUpdateAppFeatureArgs { + fake.updateAppFeatureMutex.RLock() + defer fake.updateAppFeatureMutex.RUnlock() + args := make([]FakeActorUpdateAppFeatureArgs, len(fake.updateAppFeatureArgsForCall)) + copy(args, fake.updateAppFeatureArgsForCall) + return args } func (fake *FakeActor) UpdateAppFeatureReturns(result1 v7action.Warnings, result2 error) { @@ -18703,9 +21015,7 @@ func (fake *FakeActor) UpdateAppFeatureReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) UpdateApplication(arg1 resources.Application) (resources.Application, v7action.Warnings, error) { fake.updateApplicationMutex.Lock() ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)] - fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct { - arg1 resources.Application - }{arg1}) + fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, FakeActorUpdateApplicationArgs{arg1}) stub := fake.UpdateApplicationStub fakeReturns := fake.updateApplicationReturns fake.recordInvocation("UpdateApplication", []interface{}{arg1}) @@ -18735,7 +21045,15 @@ func (fake *FakeActor) UpdateApplicationArgsForCall(i int) resources.Application fake.updateApplicationMutex.RLock() defer fake.updateApplicationMutex.RUnlock() argsForCall := fake.updateApplicationArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) UpdateApplicationArgs() []FakeActorUpdateApplicationArgs { + fake.updateApplicationMutex.RLock() + defer fake.updateApplicationMutex.RUnlock() + args := make([]FakeActorUpdateApplicationArgs, len(fake.updateApplicationArgsForCall)) + copy(args, fake.updateApplicationArgsForCall) + return args } func (fake *FakeActor) UpdateApplicationReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) { @@ -18770,11 +21088,7 @@ func (fake *FakeActor) UpdateApplicationReturnsOnCall(i int, result1 resources.A func (fake *FakeActor) UpdateApplicationLabelsByApplicationName(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) { fake.updateApplicationLabelsByApplicationNameMutex.Lock() ret, specificReturn := fake.updateApplicationLabelsByApplicationNameReturnsOnCall[len(fake.updateApplicationLabelsByApplicationNameArgsForCall)] - fake.updateApplicationLabelsByApplicationNameArgsForCall = append(fake.updateApplicationLabelsByApplicationNameArgsForCall, struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - }{arg1, arg2, arg3}) + fake.updateApplicationLabelsByApplicationNameArgsForCall = append(fake.updateApplicationLabelsByApplicationNameArgsForCall, FakeActorUpdateApplicationLabelsByApplicationNameArgs{arg1, arg2, arg3}) stub := fake.UpdateApplicationLabelsByApplicationNameStub fakeReturns := fake.updateApplicationLabelsByApplicationNameReturns fake.recordInvocation("UpdateApplicationLabelsByApplicationName", []interface{}{arg1, arg2, arg3}) @@ -18804,7 +21118,15 @@ func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameArgsForCall(i int fake.updateApplicationLabelsByApplicationNameMutex.RLock() defer fake.updateApplicationLabelsByApplicationNameMutex.RUnlock() argsForCall := fake.updateApplicationLabelsByApplicationNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameArgs() []FakeActorUpdateApplicationLabelsByApplicationNameArgs { + fake.updateApplicationLabelsByApplicationNameMutex.RLock() + defer fake.updateApplicationLabelsByApplicationNameMutex.RUnlock() + args := make([]FakeActorUpdateApplicationLabelsByApplicationNameArgs, len(fake.updateApplicationLabelsByApplicationNameArgsForCall)) + copy(args, fake.updateApplicationLabelsByApplicationNameArgsForCall) + return args } func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameReturns(result1 v7action.Warnings, result2 error) { @@ -18836,12 +21158,7 @@ func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameReturnsOnCall(i i func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string, arg4 resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) { fake.updateBuildpackByNameAndStackAndLifecycleMutex.Lock() ret, specificReturn := fake.updateBuildpackByNameAndStackAndLifecycleReturnsOnCall[len(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall)] - fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 resources.Buildpack - }{arg1, arg2, arg3, arg4}) + fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall, FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateBuildpackByNameAndStackAndLifecycleStub fakeReturns := fake.updateBuildpackByNameAndStackAndLifecycleReturns fake.recordInvocation("UpdateBuildpackByNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3, arg4}) @@ -18871,7 +21188,15 @@ func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleArgsForCall(i in fake.updateBuildpackByNameAndStackAndLifecycleMutex.RLock() defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.RUnlock() argsForCall := fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleArgs() []FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs { + fake.updateBuildpackByNameAndStackAndLifecycleMutex.RLock() + defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.RUnlock() + args := make([]FakeActorUpdateBuildpackByNameAndStackAndLifecycleArgs, len(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall)) + copy(args, fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall) + return args } func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleReturns(result1 resources.Buildpack, result2 v7action.Warnings, result3 error) { @@ -18906,12 +21231,7 @@ func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleReturnsOnCall(i func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string, arg4 map[string]types.NullString) (v7action.Warnings, error) { fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Lock() ret, specificReturn := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall[len(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall)] - fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - }{arg1, arg2, arg3, arg4}) + fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall, FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub fakeReturns := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns fake.recordInvocation("UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3, arg4}) @@ -18941,7 +21261,15 @@ func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleA fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RLock() defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RUnlock() argsForCall := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs() []FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs { + fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RLock() + defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RUnlock() + args := make([]FakeActorUpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgs, len(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall)) + copy(args, fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall) + return args } func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns(result1 v7action.Warnings, result2 error) { @@ -18973,11 +21301,7 @@ func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleR func (fake *FakeActor) UpdateDestination(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) { fake.updateDestinationMutex.Lock() ret, specificReturn := fake.updateDestinationReturnsOnCall[len(fake.updateDestinationArgsForCall)] - fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, FakeActorUpdateDestinationArgs{arg1, arg2, arg3}) stub := fake.UpdateDestinationStub fakeReturns := fake.updateDestinationReturns fake.recordInvocation("UpdateDestination", []interface{}{arg1, arg2, arg3}) @@ -19007,7 +21331,15 @@ func (fake *FakeActor) UpdateDestinationArgsForCall(i int) (string, string, stri fake.updateDestinationMutex.RLock() defer fake.updateDestinationMutex.RUnlock() argsForCall := fake.updateDestinationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateDestinationArgs() []FakeActorUpdateDestinationArgs { + fake.updateDestinationMutex.RLock() + defer fake.updateDestinationMutex.RUnlock() + args := make([]FakeActorUpdateDestinationArgs, len(fake.updateDestinationArgsForCall)) + copy(args, fake.updateDestinationArgsForCall) + return args } func (fake *FakeActor) UpdateDestinationReturns(result1 v7action.Warnings, result2 error) { @@ -19039,10 +21371,7 @@ func (fake *FakeActor) UpdateDestinationReturnsOnCall(i int, result1 v7action.Wa func (fake *FakeActor) UpdateDomainLabelsByDomainName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) { fake.updateDomainLabelsByDomainNameMutex.Lock() ret, specificReturn := fake.updateDomainLabelsByDomainNameReturnsOnCall[len(fake.updateDomainLabelsByDomainNameArgsForCall)] - fake.updateDomainLabelsByDomainNameArgsForCall = append(fake.updateDomainLabelsByDomainNameArgsForCall, struct { - arg1 string - arg2 map[string]types.NullString - }{arg1, arg2}) + fake.updateDomainLabelsByDomainNameArgsForCall = append(fake.updateDomainLabelsByDomainNameArgsForCall, FakeActorUpdateDomainLabelsByDomainNameArgs{arg1, arg2}) stub := fake.UpdateDomainLabelsByDomainNameStub fakeReturns := fake.updateDomainLabelsByDomainNameReturns fake.recordInvocation("UpdateDomainLabelsByDomainName", []interface{}{arg1, arg2}) @@ -19072,7 +21401,15 @@ func (fake *FakeActor) UpdateDomainLabelsByDomainNameArgsForCall(i int) (string, fake.updateDomainLabelsByDomainNameMutex.RLock() defer fake.updateDomainLabelsByDomainNameMutex.RUnlock() argsForCall := fake.updateDomainLabelsByDomainNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateDomainLabelsByDomainNameArgs() []FakeActorUpdateDomainLabelsByDomainNameArgs { + fake.updateDomainLabelsByDomainNameMutex.RLock() + defer fake.updateDomainLabelsByDomainNameMutex.RUnlock() + args := make([]FakeActorUpdateDomainLabelsByDomainNameArgs, len(fake.updateDomainLabelsByDomainNameArgsForCall)) + copy(args, fake.updateDomainLabelsByDomainNameArgsForCall) + return args } func (fake *FakeActor) UpdateDomainLabelsByDomainNameReturns(result1 v7action.Warnings, result2 error) { @@ -19104,9 +21441,7 @@ func (fake *FakeActor) UpdateDomainLabelsByDomainNameReturnsOnCall(i int, result func (fake *FakeActor) UpdateManagedServiceInstance(arg1 v7action.UpdateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.updateManagedServiceInstanceMutex.Lock() ret, specificReturn := fake.updateManagedServiceInstanceReturnsOnCall[len(fake.updateManagedServiceInstanceArgsForCall)] - fake.updateManagedServiceInstanceArgsForCall = append(fake.updateManagedServiceInstanceArgsForCall, struct { - arg1 v7action.UpdateManagedServiceInstanceParams - }{arg1}) + fake.updateManagedServiceInstanceArgsForCall = append(fake.updateManagedServiceInstanceArgsForCall, FakeActorUpdateManagedServiceInstanceArgs{arg1}) stub := fake.UpdateManagedServiceInstanceStub fakeReturns := fake.updateManagedServiceInstanceReturns fake.recordInvocation("UpdateManagedServiceInstance", []interface{}{arg1}) @@ -19136,7 +21471,15 @@ func (fake *FakeActor) UpdateManagedServiceInstanceArgsForCall(i int) v7action.U fake.updateManagedServiceInstanceMutex.RLock() defer fake.updateManagedServiceInstanceMutex.RUnlock() argsForCall := fake.updateManagedServiceInstanceArgsForCall[i] - return argsForCall.arg1 + return argsForCall.Arg1 +} + +func (fake *FakeActor) UpdateManagedServiceInstanceArgs() []FakeActorUpdateManagedServiceInstanceArgs { + fake.updateManagedServiceInstanceMutex.RLock() + defer fake.updateManagedServiceInstanceMutex.RUnlock() + args := make([]FakeActorUpdateManagedServiceInstanceArgs, len(fake.updateManagedServiceInstanceArgsForCall)) + copy(args, fake.updateManagedServiceInstanceArgsForCall) + return args } func (fake *FakeActor) UpdateManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -19171,10 +21514,7 @@ func (fake *FakeActor) UpdateManagedServiceInstanceReturnsOnCall(i int, result1 func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) { fake.updateOrganizationLabelsByOrganizationNameMutex.Lock() ret, specificReturn := fake.updateOrganizationLabelsByOrganizationNameReturnsOnCall[len(fake.updateOrganizationLabelsByOrganizationNameArgsForCall)] - fake.updateOrganizationLabelsByOrganizationNameArgsForCall = append(fake.updateOrganizationLabelsByOrganizationNameArgsForCall, struct { - arg1 string - arg2 map[string]types.NullString - }{arg1, arg2}) + fake.updateOrganizationLabelsByOrganizationNameArgsForCall = append(fake.updateOrganizationLabelsByOrganizationNameArgsForCall, FakeActorUpdateOrganizationLabelsByOrganizationNameArgs{arg1, arg2}) stub := fake.UpdateOrganizationLabelsByOrganizationNameStub fakeReturns := fake.updateOrganizationLabelsByOrganizationNameReturns fake.recordInvocation("UpdateOrganizationLabelsByOrganizationName", []interface{}{arg1, arg2}) @@ -19204,7 +21544,15 @@ func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameArgsForCall(i i fake.updateOrganizationLabelsByOrganizationNameMutex.RLock() defer fake.updateOrganizationLabelsByOrganizationNameMutex.RUnlock() argsForCall := fake.updateOrganizationLabelsByOrganizationNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameArgs() []FakeActorUpdateOrganizationLabelsByOrganizationNameArgs { + fake.updateOrganizationLabelsByOrganizationNameMutex.RLock() + defer fake.updateOrganizationLabelsByOrganizationNameMutex.RUnlock() + args := make([]FakeActorUpdateOrganizationLabelsByOrganizationNameArgs, len(fake.updateOrganizationLabelsByOrganizationNameArgsForCall)) + copy(args, fake.updateOrganizationLabelsByOrganizationNameArgsForCall) + return args } func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameReturns(result1 v7action.Warnings, result2 error) { @@ -19236,11 +21584,7 @@ func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameReturnsOnCall(i func (fake *FakeActor) UpdateOrganizationQuota(arg1 string, arg2 string, arg3 v7action.QuotaLimits) (v7action.Warnings, error) { fake.updateOrganizationQuotaMutex.Lock() ret, specificReturn := fake.updateOrganizationQuotaReturnsOnCall[len(fake.updateOrganizationQuotaArgsForCall)] - fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.QuotaLimits - }{arg1, arg2, arg3}) + fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, FakeActorUpdateOrganizationQuotaArgs{arg1, arg2, arg3}) stub := fake.UpdateOrganizationQuotaStub fakeReturns := fake.updateOrganizationQuotaReturns fake.recordInvocation("UpdateOrganizationQuota", []interface{}{arg1, arg2, arg3}) @@ -19270,7 +21614,15 @@ func (fake *FakeActor) UpdateOrganizationQuotaArgsForCall(i int) (string, string fake.updateOrganizationQuotaMutex.RLock() defer fake.updateOrganizationQuotaMutex.RUnlock() argsForCall := fake.updateOrganizationQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateOrganizationQuotaArgs() []FakeActorUpdateOrganizationQuotaArgs { + fake.updateOrganizationQuotaMutex.RLock() + defer fake.updateOrganizationQuotaMutex.RUnlock() + args := make([]FakeActorUpdateOrganizationQuotaArgs, len(fake.updateOrganizationQuotaArgsForCall)) + copy(args, fake.updateOrganizationQuotaArgsForCall) + return args } func (fake *FakeActor) UpdateOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -19302,11 +21654,7 @@ func (fake *FakeActor) UpdateOrganizationQuotaReturnsOnCall(i int, result1 v7act func (fake *FakeActor) UpdateProcessByTypeAndApplication(arg1 string, arg2 string, arg3 resources.Process) (v7action.Warnings, error) { fake.updateProcessByTypeAndApplicationMutex.Lock() ret, specificReturn := fake.updateProcessByTypeAndApplicationReturnsOnCall[len(fake.updateProcessByTypeAndApplicationArgsForCall)] - fake.updateProcessByTypeAndApplicationArgsForCall = append(fake.updateProcessByTypeAndApplicationArgsForCall, struct { - arg1 string - arg2 string - arg3 resources.Process - }{arg1, arg2, arg3}) + fake.updateProcessByTypeAndApplicationArgsForCall = append(fake.updateProcessByTypeAndApplicationArgsForCall, FakeActorUpdateProcessByTypeAndApplicationArgs{arg1, arg2, arg3}) stub := fake.UpdateProcessByTypeAndApplicationStub fakeReturns := fake.updateProcessByTypeAndApplicationReturns fake.recordInvocation("UpdateProcessByTypeAndApplication", []interface{}{arg1, arg2, arg3}) @@ -19336,7 +21684,15 @@ func (fake *FakeActor) UpdateProcessByTypeAndApplicationArgsForCall(i int) (stri fake.updateProcessByTypeAndApplicationMutex.RLock() defer fake.updateProcessByTypeAndApplicationMutex.RUnlock() argsForCall := fake.updateProcessByTypeAndApplicationArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateProcessByTypeAndApplicationArgs() []FakeActorUpdateProcessByTypeAndApplicationArgs { + fake.updateProcessByTypeAndApplicationMutex.RLock() + defer fake.updateProcessByTypeAndApplicationMutex.RUnlock() + args := make([]FakeActorUpdateProcessByTypeAndApplicationArgs, len(fake.updateProcessByTypeAndApplicationArgsForCall)) + copy(args, fake.updateProcessByTypeAndApplicationArgsForCall) + return args } func (fake *FakeActor) UpdateProcessByTypeAndApplicationReturns(result1 v7action.Warnings, result2 error) { @@ -19368,10 +21724,7 @@ func (fake *FakeActor) UpdateProcessByTypeAndApplicationReturnsOnCall(i int, res func (fake *FakeActor) UpdateRoute(arg1 string, arg2 map[string]*string) (resources.Route, v7action.Warnings, error) { fake.updateRouteMutex.Lock() ret, specificReturn := fake.updateRouteReturnsOnCall[len(fake.updateRouteArgsForCall)] - fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, struct { - arg1 string - arg2 map[string]*string - }{arg1, arg2}) + fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, FakeActorUpdateRouteArgs{arg1, arg2}) stub := fake.UpdateRouteStub fakeReturns := fake.updateRouteReturns fake.recordInvocation("UpdateRoute", []interface{}{arg1, arg2}) @@ -19401,7 +21754,15 @@ func (fake *FakeActor) UpdateRouteArgsForCall(i int) (string, map[string]*string fake.updateRouteMutex.RLock() defer fake.updateRouteMutex.RUnlock() argsForCall := fake.updateRouteArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateRouteArgs() []FakeActorUpdateRouteArgs { + fake.updateRouteMutex.RLock() + defer fake.updateRouteMutex.RUnlock() + args := make([]FakeActorUpdateRouteArgs, len(fake.updateRouteArgsForCall)) + copy(args, fake.updateRouteArgsForCall) + return args } func (fake *FakeActor) UpdateRouteReturns(result1 resources.Route, result2 v7action.Warnings, result3 error) { @@ -19436,11 +21797,7 @@ func (fake *FakeActor) UpdateRouteReturnsOnCall(i int, result1 resources.Route, func (fake *FakeActor) UpdateRouteLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) { fake.updateRouteLabelsMutex.Lock() ret, specificReturn := fake.updateRouteLabelsReturnsOnCall[len(fake.updateRouteLabelsArgsForCall)] - fake.updateRouteLabelsArgsForCall = append(fake.updateRouteLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - }{arg1, arg2, arg3}) + fake.updateRouteLabelsArgsForCall = append(fake.updateRouteLabelsArgsForCall, FakeActorUpdateRouteLabelsArgs{arg1, arg2, arg3}) stub := fake.UpdateRouteLabelsStub fakeReturns := fake.updateRouteLabelsReturns fake.recordInvocation("UpdateRouteLabels", []interface{}{arg1, arg2, arg3}) @@ -19470,7 +21827,15 @@ func (fake *FakeActor) UpdateRouteLabelsArgsForCall(i int) (string, string, map[ fake.updateRouteLabelsMutex.RLock() defer fake.updateRouteLabelsMutex.RUnlock() argsForCall := fake.updateRouteLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateRouteLabelsArgs() []FakeActorUpdateRouteLabelsArgs { + fake.updateRouteLabelsMutex.RLock() + defer fake.updateRouteLabelsMutex.RUnlock() + args := make([]FakeActorUpdateRouteLabelsArgs, len(fake.updateRouteLabelsArgsForCall)) + copy(args, fake.updateRouteLabelsArgsForCall) + return args } func (fake *FakeActor) UpdateRouteLabelsReturns(result1 v7action.Warnings, result2 error) { @@ -19502,12 +21867,7 @@ func (fake *FakeActor) UpdateRouteLabelsReturnsOnCall(i int, result1 v7action.Wa func (fake *FakeActor) UpdateRoutePolicyLabels(arg1 string, arg2 string, arg3 string, arg4 map[string]types.NullString) (v7action.Warnings, error) { fake.updateRoutePolicyLabelsMutex.Lock() ret, specificReturn := fake.updateRoutePolicyLabelsReturnsOnCall[len(fake.updateRoutePolicyLabelsArgsForCall)] - fake.updateRoutePolicyLabelsArgsForCall = append(fake.updateRoutePolicyLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - }{arg1, arg2, arg3, arg4}) + fake.updateRoutePolicyLabelsArgsForCall = append(fake.updateRoutePolicyLabelsArgsForCall, FakeActorUpdateRoutePolicyLabelsArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateRoutePolicyLabelsStub fakeReturns := fake.updateRoutePolicyLabelsReturns fake.recordInvocation("UpdateRoutePolicyLabels", []interface{}{arg1, arg2, arg3, arg4}) @@ -19537,7 +21897,15 @@ func (fake *FakeActor) UpdateRoutePolicyLabelsArgsForCall(i int) (string, string fake.updateRoutePolicyLabelsMutex.RLock() defer fake.updateRoutePolicyLabelsMutex.RUnlock() argsForCall := fake.updateRoutePolicyLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateRoutePolicyLabelsArgs() []FakeActorUpdateRoutePolicyLabelsArgs { + fake.updateRoutePolicyLabelsMutex.RLock() + defer fake.updateRoutePolicyLabelsMutex.RUnlock() + args := make([]FakeActorUpdateRoutePolicyLabelsArgs, len(fake.updateRoutePolicyLabelsArgsForCall)) + copy(args, fake.updateRoutePolicyLabelsArgsForCall) + return args } func (fake *FakeActor) UpdateRoutePolicyLabelsReturns(result1 v7action.Warnings, result2 error) { @@ -19569,10 +21937,7 @@ func (fake *FakeActor) UpdateRoutePolicyLabelsReturnsOnCall(i int, result1 v7act func (fake *FakeActor) UpdateSecurityGroup(arg1 string, arg2 string) (v7action.Warnings, error) { fake.updateSecurityGroupMutex.Lock() ret, specificReturn := fake.updateSecurityGroupReturnsOnCall[len(fake.updateSecurityGroupArgsForCall)] - fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, FakeActorUpdateSecurityGroupArgs{arg1, arg2}) stub := fake.UpdateSecurityGroupStub fakeReturns := fake.updateSecurityGroupReturns fake.recordInvocation("UpdateSecurityGroup", []interface{}{arg1, arg2}) @@ -19602,7 +21967,15 @@ func (fake *FakeActor) UpdateSecurityGroupArgsForCall(i int) (string, string) { fake.updateSecurityGroupMutex.RLock() defer fake.updateSecurityGroupMutex.RUnlock() argsForCall := fake.updateSecurityGroupArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateSecurityGroupArgs() []FakeActorUpdateSecurityGroupArgs { + fake.updateSecurityGroupMutex.RLock() + defer fake.updateSecurityGroupMutex.RUnlock() + args := make([]FakeActorUpdateSecurityGroupArgs, len(fake.updateSecurityGroupArgsForCall)) + copy(args, fake.updateSecurityGroupArgsForCall) + return args } func (fake *FakeActor) UpdateSecurityGroupReturns(result1 v7action.Warnings, result2 error) { @@ -19634,11 +22007,7 @@ func (fake *FakeActor) UpdateSecurityGroupReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) UpdateSecurityGroupGloballyEnabled(arg1 string, arg2 constanta.SecurityGroupLifecycle, arg3 bool) (v7action.Warnings, error) { fake.updateSecurityGroupGloballyEnabledMutex.Lock() ret, specificReturn := fake.updateSecurityGroupGloballyEnabledReturnsOnCall[len(fake.updateSecurityGroupGloballyEnabledArgsForCall)] - fake.updateSecurityGroupGloballyEnabledArgsForCall = append(fake.updateSecurityGroupGloballyEnabledArgsForCall, struct { - arg1 string - arg2 constanta.SecurityGroupLifecycle - arg3 bool - }{arg1, arg2, arg3}) + fake.updateSecurityGroupGloballyEnabledArgsForCall = append(fake.updateSecurityGroupGloballyEnabledArgsForCall, FakeActorUpdateSecurityGroupGloballyEnabledArgs{arg1, arg2, arg3}) stub := fake.UpdateSecurityGroupGloballyEnabledStub fakeReturns := fake.updateSecurityGroupGloballyEnabledReturns fake.recordInvocation("UpdateSecurityGroupGloballyEnabled", []interface{}{arg1, arg2, arg3}) @@ -19668,7 +22037,15 @@ func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledArgsForCall(i int) (str fake.updateSecurityGroupGloballyEnabledMutex.RLock() defer fake.updateSecurityGroupGloballyEnabledMutex.RUnlock() argsForCall := fake.updateSecurityGroupGloballyEnabledArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledArgs() []FakeActorUpdateSecurityGroupGloballyEnabledArgs { + fake.updateSecurityGroupGloballyEnabledMutex.RLock() + defer fake.updateSecurityGroupGloballyEnabledMutex.RUnlock() + args := make([]FakeActorUpdateSecurityGroupGloballyEnabledArgs, len(fake.updateSecurityGroupGloballyEnabledArgsForCall)) + copy(args, fake.updateSecurityGroupGloballyEnabledArgsForCall) + return args } func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledReturns(result1 v7action.Warnings, result2 error) { @@ -19700,10 +22077,7 @@ func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledReturnsOnCall(i int, re func (fake *FakeActor) UpdateServiceBroker(arg1 string, arg2 resources.ServiceBroker) (v7action.Warnings, error) { fake.updateServiceBrokerMutex.Lock() ret, specificReturn := fake.updateServiceBrokerReturnsOnCall[len(fake.updateServiceBrokerArgsForCall)] - fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, struct { - arg1 string - arg2 resources.ServiceBroker - }{arg1, arg2}) + fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, FakeActorUpdateServiceBrokerArgs{arg1, arg2}) stub := fake.UpdateServiceBrokerStub fakeReturns := fake.updateServiceBrokerReturns fake.recordInvocation("UpdateServiceBroker", []interface{}{arg1, arg2}) @@ -19733,7 +22107,15 @@ func (fake *FakeActor) UpdateServiceBrokerArgsForCall(i int) (string, resources. fake.updateServiceBrokerMutex.RLock() defer fake.updateServiceBrokerMutex.RUnlock() argsForCall := fake.updateServiceBrokerArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateServiceBrokerArgs() []FakeActorUpdateServiceBrokerArgs { + fake.updateServiceBrokerMutex.RLock() + defer fake.updateServiceBrokerMutex.RUnlock() + args := make([]FakeActorUpdateServiceBrokerArgs, len(fake.updateServiceBrokerArgsForCall)) + copy(args, fake.updateServiceBrokerArgsForCall) + return args } func (fake *FakeActor) UpdateServiceBrokerReturns(result1 v7action.Warnings, result2 error) { @@ -19765,10 +22147,7 @@ func (fake *FakeActor) UpdateServiceBrokerReturnsOnCall(i int, result1 v7action. func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) { fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Lock() ret, specificReturn := fake.updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall[len(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall)] - fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall = append(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall, struct { - arg1 string - arg2 map[string]types.NullString - }{arg1, arg2}) + fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall = append(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall, FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs{arg1, arg2}) stub := fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub fakeReturns := fake.updateServiceBrokerLabelsByServiceBrokerNameReturns fake.recordInvocation("UpdateServiceBrokerLabelsByServiceBrokerName", []interface{}{arg1, arg2}) @@ -19798,7 +22177,15 @@ func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameArgsForCall(i fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RLock() defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RUnlock() argsForCall := fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameArgs() []FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs { + fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RLock() + defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RUnlock() + args := make([]FakeActorUpdateServiceBrokerLabelsByServiceBrokerNameArgs, len(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall)) + copy(args, fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall) + return args } func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameReturns(result1 v7action.Warnings, result2 error) { @@ -19830,11 +22217,7 @@ func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall func (fake *FakeActor) UpdateServiceInstanceLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) { fake.updateServiceInstanceLabelsMutex.Lock() ret, specificReturn := fake.updateServiceInstanceLabelsReturnsOnCall[len(fake.updateServiceInstanceLabelsArgsForCall)] - fake.updateServiceInstanceLabelsArgsForCall = append(fake.updateServiceInstanceLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - }{arg1, arg2, arg3}) + fake.updateServiceInstanceLabelsArgsForCall = append(fake.updateServiceInstanceLabelsArgsForCall, FakeActorUpdateServiceInstanceLabelsArgs{arg1, arg2, arg3}) stub := fake.UpdateServiceInstanceLabelsStub fakeReturns := fake.updateServiceInstanceLabelsReturns fake.recordInvocation("UpdateServiceInstanceLabels", []interface{}{arg1, arg2, arg3}) @@ -19864,7 +22247,15 @@ func (fake *FakeActor) UpdateServiceInstanceLabelsArgsForCall(i int) (string, st fake.updateServiceInstanceLabelsMutex.RLock() defer fake.updateServiceInstanceLabelsMutex.RUnlock() argsForCall := fake.updateServiceInstanceLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateServiceInstanceLabelsArgs() []FakeActorUpdateServiceInstanceLabelsArgs { + fake.updateServiceInstanceLabelsMutex.RLock() + defer fake.updateServiceInstanceLabelsMutex.RUnlock() + args := make([]FakeActorUpdateServiceInstanceLabelsArgs, len(fake.updateServiceInstanceLabelsArgsForCall)) + copy(args, fake.updateServiceInstanceLabelsArgsForCall) + return args } func (fake *FakeActor) UpdateServiceInstanceLabelsReturns(result1 v7action.Warnings, result2 error) { @@ -19896,11 +22287,7 @@ func (fake *FakeActor) UpdateServiceInstanceLabelsReturnsOnCall(i int, result1 v func (fake *FakeActor) UpdateServiceOfferingLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) { fake.updateServiceOfferingLabelsMutex.Lock() ret, specificReturn := fake.updateServiceOfferingLabelsReturnsOnCall[len(fake.updateServiceOfferingLabelsArgsForCall)] - fake.updateServiceOfferingLabelsArgsForCall = append(fake.updateServiceOfferingLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - }{arg1, arg2, arg3}) + fake.updateServiceOfferingLabelsArgsForCall = append(fake.updateServiceOfferingLabelsArgsForCall, FakeActorUpdateServiceOfferingLabelsArgs{arg1, arg2, arg3}) stub := fake.UpdateServiceOfferingLabelsStub fakeReturns := fake.updateServiceOfferingLabelsReturns fake.recordInvocation("UpdateServiceOfferingLabels", []interface{}{arg1, arg2, arg3}) @@ -19930,7 +22317,15 @@ func (fake *FakeActor) UpdateServiceOfferingLabelsArgsForCall(i int) (string, st fake.updateServiceOfferingLabelsMutex.RLock() defer fake.updateServiceOfferingLabelsMutex.RUnlock() argsForCall := fake.updateServiceOfferingLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateServiceOfferingLabelsArgs() []FakeActorUpdateServiceOfferingLabelsArgs { + fake.updateServiceOfferingLabelsMutex.RLock() + defer fake.updateServiceOfferingLabelsMutex.RUnlock() + args := make([]FakeActorUpdateServiceOfferingLabelsArgs, len(fake.updateServiceOfferingLabelsArgsForCall)) + copy(args, fake.updateServiceOfferingLabelsArgsForCall) + return args } func (fake *FakeActor) UpdateServiceOfferingLabelsReturns(result1 v7action.Warnings, result2 error) { @@ -19962,12 +22357,7 @@ func (fake *FakeActor) UpdateServiceOfferingLabelsReturnsOnCall(i int, result1 v func (fake *FakeActor) UpdateServicePlanLabels(arg1 string, arg2 string, arg3 string, arg4 map[string]types.NullString) (v7action.Warnings, error) { fake.updateServicePlanLabelsMutex.Lock() ret, specificReturn := fake.updateServicePlanLabelsReturnsOnCall[len(fake.updateServicePlanLabelsArgsForCall)] - fake.updateServicePlanLabelsArgsForCall = append(fake.updateServicePlanLabelsArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 map[string]types.NullString - }{arg1, arg2, arg3, arg4}) + fake.updateServicePlanLabelsArgsForCall = append(fake.updateServicePlanLabelsArgsForCall, FakeActorUpdateServicePlanLabelsArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateServicePlanLabelsStub fakeReturns := fake.updateServicePlanLabelsReturns fake.recordInvocation("UpdateServicePlanLabels", []interface{}{arg1, arg2, arg3, arg4}) @@ -19997,7 +22387,15 @@ func (fake *FakeActor) UpdateServicePlanLabelsArgsForCall(i int) (string, string fake.updateServicePlanLabelsMutex.RLock() defer fake.updateServicePlanLabelsMutex.RUnlock() argsForCall := fake.updateServicePlanLabelsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateServicePlanLabelsArgs() []FakeActorUpdateServicePlanLabelsArgs { + fake.updateServicePlanLabelsMutex.RLock() + defer fake.updateServicePlanLabelsMutex.RUnlock() + args := make([]FakeActorUpdateServicePlanLabelsArgs, len(fake.updateServicePlanLabelsArgsForCall)) + copy(args, fake.updateServicePlanLabelsArgsForCall) + return args } func (fake *FakeActor) UpdateServicePlanLabelsReturns(result1 v7action.Warnings, result2 error) { @@ -20029,12 +22427,7 @@ func (fake *FakeActor) UpdateServicePlanLabelsReturnsOnCall(i int, result1 v7act func (fake *FakeActor) UpdateSpaceFeature(arg1 string, arg2 string, arg3 bool, arg4 string) (v7action.Warnings, error) { fake.updateSpaceFeatureMutex.Lock() ret, specificReturn := fake.updateSpaceFeatureReturnsOnCall[len(fake.updateSpaceFeatureArgsForCall)] - fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, struct { - arg1 string - arg2 string - arg3 bool - arg4 string - }{arg1, arg2, arg3, arg4}) + fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, FakeActorUpdateSpaceFeatureArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateSpaceFeatureStub fakeReturns := fake.updateSpaceFeatureReturns fake.recordInvocation("UpdateSpaceFeature", []interface{}{arg1, arg2, arg3, arg4}) @@ -20064,7 +22457,15 @@ func (fake *FakeActor) UpdateSpaceFeatureArgsForCall(i int) (string, string, boo fake.updateSpaceFeatureMutex.RLock() defer fake.updateSpaceFeatureMutex.RUnlock() argsForCall := fake.updateSpaceFeatureArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateSpaceFeatureArgs() []FakeActorUpdateSpaceFeatureArgs { + fake.updateSpaceFeatureMutex.RLock() + defer fake.updateSpaceFeatureMutex.RUnlock() + args := make([]FakeActorUpdateSpaceFeatureArgs, len(fake.updateSpaceFeatureArgsForCall)) + copy(args, fake.updateSpaceFeatureArgsForCall) + return args } func (fake *FakeActor) UpdateSpaceFeatureReturns(result1 v7action.Warnings, result2 error) { @@ -20096,11 +22497,7 @@ func (fake *FakeActor) UpdateSpaceFeatureReturnsOnCall(i int, result1 v7action.W func (fake *FakeActor) UpdateSpaceLabelsBySpaceName(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) { fake.updateSpaceLabelsBySpaceNameMutex.Lock() ret, specificReturn := fake.updateSpaceLabelsBySpaceNameReturnsOnCall[len(fake.updateSpaceLabelsBySpaceNameArgsForCall)] - fake.updateSpaceLabelsBySpaceNameArgsForCall = append(fake.updateSpaceLabelsBySpaceNameArgsForCall, struct { - arg1 string - arg2 string - arg3 map[string]types.NullString - }{arg1, arg2, arg3}) + fake.updateSpaceLabelsBySpaceNameArgsForCall = append(fake.updateSpaceLabelsBySpaceNameArgsForCall, FakeActorUpdateSpaceLabelsBySpaceNameArgs{arg1, arg2, arg3}) stub := fake.UpdateSpaceLabelsBySpaceNameStub fakeReturns := fake.updateSpaceLabelsBySpaceNameReturns fake.recordInvocation("UpdateSpaceLabelsBySpaceName", []interface{}{arg1, arg2, arg3}) @@ -20130,7 +22527,15 @@ func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameArgsForCall(i int) (string, s fake.updateSpaceLabelsBySpaceNameMutex.RLock() defer fake.updateSpaceLabelsBySpaceNameMutex.RUnlock() argsForCall := fake.updateSpaceLabelsBySpaceNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameArgs() []FakeActorUpdateSpaceLabelsBySpaceNameArgs { + fake.updateSpaceLabelsBySpaceNameMutex.RLock() + defer fake.updateSpaceLabelsBySpaceNameMutex.RUnlock() + args := make([]FakeActorUpdateSpaceLabelsBySpaceNameArgs, len(fake.updateSpaceLabelsBySpaceNameArgsForCall)) + copy(args, fake.updateSpaceLabelsBySpaceNameArgsForCall) + return args } func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameReturns(result1 v7action.Warnings, result2 error) { @@ -20162,12 +22567,7 @@ func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameReturnsOnCall(i int, result1 func (fake *FakeActor) UpdateSpaceQuota(arg1 string, arg2 string, arg3 string, arg4 v7action.QuotaLimits) (v7action.Warnings, error) { fake.updateSpaceQuotaMutex.Lock() ret, specificReturn := fake.updateSpaceQuotaReturnsOnCall[len(fake.updateSpaceQuotaArgsForCall)] - fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, struct { - arg1 string - arg2 string - arg3 string - arg4 v7action.QuotaLimits - }{arg1, arg2, arg3, arg4}) + fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, FakeActorUpdateSpaceQuotaArgs{arg1, arg2, arg3, arg4}) stub := fake.UpdateSpaceQuotaStub fakeReturns := fake.updateSpaceQuotaReturns fake.recordInvocation("UpdateSpaceQuota", []interface{}{arg1, arg2, arg3, arg4}) @@ -20197,7 +22597,15 @@ func (fake *FakeActor) UpdateSpaceQuotaArgsForCall(i int) (string, string, strin fake.updateSpaceQuotaMutex.RLock() defer fake.updateSpaceQuotaMutex.RUnlock() argsForCall := fake.updateSpaceQuotaArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UpdateSpaceQuotaArgs() []FakeActorUpdateSpaceQuotaArgs { + fake.updateSpaceQuotaMutex.RLock() + defer fake.updateSpaceQuotaMutex.RUnlock() + args := make([]FakeActorUpdateSpaceQuotaArgs, len(fake.updateSpaceQuotaArgsForCall)) + copy(args, fake.updateSpaceQuotaArgsForCall) + return args } func (fake *FakeActor) UpdateSpaceQuotaReturns(result1 v7action.Warnings, result2 error) { @@ -20229,11 +22637,7 @@ func (fake *FakeActor) UpdateSpaceQuotaReturnsOnCall(i int, result1 v7action.War func (fake *FakeActor) UpdateStack(arg1 string, arg2 string, arg3 string) (resources.Stack, v7action.Warnings, error) { fake.updateStackMutex.Lock() ret, specificReturn := fake.updateStackReturnsOnCall[len(fake.updateStackArgsForCall)] - fake.updateStackArgsForCall = append(fake.updateStackArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.updateStackArgsForCall = append(fake.updateStackArgsForCall, FakeActorUpdateStackArgs{arg1, arg2, arg3}) stub := fake.UpdateStackStub fakeReturns := fake.updateStackReturns fake.recordInvocation("UpdateStack", []interface{}{arg1, arg2, arg3}) @@ -20263,7 +22667,15 @@ func (fake *FakeActor) UpdateStackArgsForCall(i int) (string, string, string) { fake.updateStackMutex.RLock() defer fake.updateStackMutex.RUnlock() argsForCall := fake.updateStackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateStackArgs() []FakeActorUpdateStackArgs { + fake.updateStackMutex.RLock() + defer fake.updateStackMutex.RUnlock() + args := make([]FakeActorUpdateStackArgs, len(fake.updateStackArgsForCall)) + copy(args, fake.updateStackArgsForCall) + return args } func (fake *FakeActor) UpdateStackReturns(result1 resources.Stack, result2 v7action.Warnings, result3 error) { @@ -20298,10 +22710,7 @@ func (fake *FakeActor) UpdateStackReturnsOnCall(i int, result1 resources.Stack, func (fake *FakeActor) UpdateStackLabelsByStackName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) { fake.updateStackLabelsByStackNameMutex.Lock() ret, specificReturn := fake.updateStackLabelsByStackNameReturnsOnCall[len(fake.updateStackLabelsByStackNameArgsForCall)] - fake.updateStackLabelsByStackNameArgsForCall = append(fake.updateStackLabelsByStackNameArgsForCall, struct { - arg1 string - arg2 map[string]types.NullString - }{arg1, arg2}) + fake.updateStackLabelsByStackNameArgsForCall = append(fake.updateStackLabelsByStackNameArgsForCall, FakeActorUpdateStackLabelsByStackNameArgs{arg1, arg2}) stub := fake.UpdateStackLabelsByStackNameStub fakeReturns := fake.updateStackLabelsByStackNameReturns fake.recordInvocation("UpdateStackLabelsByStackName", []interface{}{arg1, arg2}) @@ -20331,7 +22740,15 @@ func (fake *FakeActor) UpdateStackLabelsByStackNameArgsForCall(i int) (string, m fake.updateStackLabelsByStackNameMutex.RLock() defer fake.updateStackLabelsByStackNameMutex.RUnlock() argsForCall := fake.updateStackLabelsByStackNameArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpdateStackLabelsByStackNameArgs() []FakeActorUpdateStackLabelsByStackNameArgs { + fake.updateStackLabelsByStackNameMutex.RLock() + defer fake.updateStackLabelsByStackNameMutex.RUnlock() + args := make([]FakeActorUpdateStackLabelsByStackNameArgs, len(fake.updateStackLabelsByStackNameArgsForCall)) + copy(args, fake.updateStackLabelsByStackNameArgsForCall) + return args } func (fake *FakeActor) UpdateStackLabelsByStackNameReturns(result1 v7action.Warnings, result2 error) { @@ -20363,11 +22780,7 @@ func (fake *FakeActor) UpdateStackLabelsByStackNameReturnsOnCall(i int, result1 func (fake *FakeActor) UpdateUserPassword(arg1 string, arg2 string, arg3 string) error { fake.updateUserPasswordMutex.Lock() ret, specificReturn := fake.updateUserPasswordReturnsOnCall[len(fake.updateUserPasswordArgsForCall)] - fake.updateUserPasswordArgsForCall = append(fake.updateUserPasswordArgsForCall, struct { - arg1 string - arg2 string - arg3 string - }{arg1, arg2, arg3}) + fake.updateUserPasswordArgsForCall = append(fake.updateUserPasswordArgsForCall, FakeActorUpdateUserPasswordArgs{arg1, arg2, arg3}) stub := fake.UpdateUserPasswordStub fakeReturns := fake.updateUserPasswordReturns fake.recordInvocation("UpdateUserPassword", []interface{}{arg1, arg2, arg3}) @@ -20397,7 +22810,15 @@ func (fake *FakeActor) UpdateUserPasswordArgsForCall(i int) (string, string, str fake.updateUserPasswordMutex.RLock() defer fake.updateUserPasswordMutex.RUnlock() argsForCall := fake.updateUserPasswordArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateUserPasswordArgs() []FakeActorUpdateUserPasswordArgs { + fake.updateUserPasswordMutex.RLock() + defer fake.updateUserPasswordMutex.RUnlock() + args := make([]FakeActorUpdateUserPasswordArgs, len(fake.updateUserPasswordArgsForCall)) + copy(args, fake.updateUserPasswordArgsForCall) + return args } func (fake *FakeActor) UpdateUserPasswordReturns(result1 error) { @@ -20426,11 +22847,7 @@ func (fake *FakeActor) UpdateUserPasswordReturnsOnCall(i int, result1 error) { func (fake *FakeActor) UpdateUserProvidedServiceInstance(arg1 string, arg2 string, arg3 resources.ServiceInstance) (v7action.Warnings, error) { fake.updateUserProvidedServiceInstanceMutex.Lock() ret, specificReturn := fake.updateUserProvidedServiceInstanceReturnsOnCall[len(fake.updateUserProvidedServiceInstanceArgsForCall)] - fake.updateUserProvidedServiceInstanceArgsForCall = append(fake.updateUserProvidedServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - arg3 resources.ServiceInstance - }{arg1, arg2, arg3}) + fake.updateUserProvidedServiceInstanceArgsForCall = append(fake.updateUserProvidedServiceInstanceArgsForCall, FakeActorUpdateUserProvidedServiceInstanceArgs{arg1, arg2, arg3}) stub := fake.UpdateUserProvidedServiceInstanceStub fakeReturns := fake.updateUserProvidedServiceInstanceReturns fake.recordInvocation("UpdateUserProvidedServiceInstance", []interface{}{arg1, arg2, arg3}) @@ -20460,7 +22877,15 @@ func (fake *FakeActor) UpdateUserProvidedServiceInstanceArgsForCall(i int) (stri fake.updateUserProvidedServiceInstanceMutex.RLock() defer fake.updateUserProvidedServiceInstanceMutex.RUnlock() argsForCall := fake.updateUserProvidedServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UpdateUserProvidedServiceInstanceArgs() []FakeActorUpdateUserProvidedServiceInstanceArgs { + fake.updateUserProvidedServiceInstanceMutex.RLock() + defer fake.updateUserProvidedServiceInstanceMutex.RUnlock() + args := make([]FakeActorUpdateUserProvidedServiceInstanceArgs, len(fake.updateUserProvidedServiceInstanceArgsForCall)) + copy(args, fake.updateUserProvidedServiceInstanceArgsForCall) + return args } func (fake *FakeActor) UpdateUserProvidedServiceInstanceReturns(result1 v7action.Warnings, result2 error) { @@ -20492,10 +22917,7 @@ func (fake *FakeActor) UpdateUserProvidedServiceInstanceReturnsOnCall(i int, res func (fake *FakeActor) UpgradeManagedServiceInstance(arg1 string, arg2 string) (chan v7action.PollJobEvent, v7action.Warnings, error) { fake.upgradeManagedServiceInstanceMutex.Lock() ret, specificReturn := fake.upgradeManagedServiceInstanceReturnsOnCall[len(fake.upgradeManagedServiceInstanceArgsForCall)] - fake.upgradeManagedServiceInstanceArgsForCall = append(fake.upgradeManagedServiceInstanceArgsForCall, struct { - arg1 string - arg2 string - }{arg1, arg2}) + fake.upgradeManagedServiceInstanceArgsForCall = append(fake.upgradeManagedServiceInstanceArgsForCall, FakeActorUpgradeManagedServiceInstanceArgs{arg1, arg2}) stub := fake.UpgradeManagedServiceInstanceStub fakeReturns := fake.upgradeManagedServiceInstanceReturns fake.recordInvocation("UpgradeManagedServiceInstance", []interface{}{arg1, arg2}) @@ -20525,7 +22947,15 @@ func (fake *FakeActor) UpgradeManagedServiceInstanceArgsForCall(i int) (string, fake.upgradeManagedServiceInstanceMutex.RLock() defer fake.upgradeManagedServiceInstanceMutex.RUnlock() argsForCall := fake.upgradeManagedServiceInstanceArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.Arg1, argsForCall.Arg2 +} + +func (fake *FakeActor) UpgradeManagedServiceInstanceArgs() []FakeActorUpgradeManagedServiceInstanceArgs { + fake.upgradeManagedServiceInstanceMutex.RLock() + defer fake.upgradeManagedServiceInstanceMutex.RUnlock() + args := make([]FakeActorUpgradeManagedServiceInstanceArgs, len(fake.upgradeManagedServiceInstanceArgsForCall)) + copy(args, fake.upgradeManagedServiceInstanceArgsForCall) + return args } func (fake *FakeActor) UpgradeManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) { @@ -20565,12 +22995,7 @@ func (fake *FakeActor) UploadBitsPackage(arg1 resources.Package, arg2 []sharedac } fake.uploadBitsPackageMutex.Lock() ret, specificReturn := fake.uploadBitsPackageReturnsOnCall[len(fake.uploadBitsPackageArgsForCall)] - fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, struct { - arg1 resources.Package - arg2 []sharedaction.V3Resource - arg3 io.Reader - arg4 int64 - }{arg1, arg2Copy, arg3, arg4}) + fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, FakeActorUploadBitsPackageArgs{arg1, arg2Copy, arg3, arg4}) stub := fake.UploadBitsPackageStub fakeReturns := fake.uploadBitsPackageReturns fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4}) @@ -20600,7 +23025,15 @@ func (fake *FakeActor) UploadBitsPackageArgsForCall(i int) (resources.Package, [ fake.uploadBitsPackageMutex.RLock() defer fake.uploadBitsPackageMutex.RUnlock() argsForCall := fake.uploadBitsPackageArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UploadBitsPackageArgs() []FakeActorUploadBitsPackageArgs { + fake.uploadBitsPackageMutex.RLock() + defer fake.uploadBitsPackageMutex.RUnlock() + args := make([]FakeActorUploadBitsPackageArgs, len(fake.uploadBitsPackageArgsForCall)) + copy(args, fake.uploadBitsPackageArgsForCall) + return args } func (fake *FakeActor) UploadBitsPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) { @@ -20635,11 +23068,7 @@ func (fake *FakeActor) UploadBitsPackageReturnsOnCall(i int, result1 resources.P func (fake *FakeActor) UploadBuildpack(arg1 string, arg2 string, arg3 v7action.SimpleProgressBar) (ccv3.JobURL, v7action.Warnings, error) { fake.uploadBuildpackMutex.Lock() ret, specificReturn := fake.uploadBuildpackReturnsOnCall[len(fake.uploadBuildpackArgsForCall)] - fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, struct { - arg1 string - arg2 string - arg3 v7action.SimpleProgressBar - }{arg1, arg2, arg3}) + fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, FakeActorUploadBuildpackArgs{arg1, arg2, arg3}) stub := fake.UploadBuildpackStub fakeReturns := fake.uploadBuildpackReturns fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3}) @@ -20669,7 +23098,15 @@ func (fake *FakeActor) UploadBuildpackArgsForCall(i int) (string, string, v7acti fake.uploadBuildpackMutex.RLock() defer fake.uploadBuildpackMutex.RUnlock() argsForCall := fake.uploadBuildpackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3 +} + +func (fake *FakeActor) UploadBuildpackArgs() []FakeActorUploadBuildpackArgs { + fake.uploadBuildpackMutex.RLock() + defer fake.uploadBuildpackMutex.RUnlock() + args := make([]FakeActorUploadBuildpackArgs, len(fake.uploadBuildpackArgsForCall)) + copy(args, fake.uploadBuildpackArgsForCall) + return args } func (fake *FakeActor) UploadBuildpackReturns(result1 ccv3.JobURL, result2 v7action.Warnings, result3 error) { @@ -20704,12 +23141,7 @@ func (fake *FakeActor) UploadBuildpackReturnsOnCall(i int, result1 ccv3.JobURL, func (fake *FakeActor) UploadDroplet(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (v7action.Warnings, error) { fake.uploadDropletMutex.Lock() ret, specificReturn := fake.uploadDropletReturnsOnCall[len(fake.uploadDropletArgsForCall)] - fake.uploadDropletArgsForCall = append(fake.uploadDropletArgsForCall, struct { - arg1 string - arg2 string - arg3 io.Reader - arg4 int64 - }{arg1, arg2, arg3, arg4}) + fake.uploadDropletArgsForCall = append(fake.uploadDropletArgsForCall, FakeActorUploadDropletArgs{arg1, arg2, arg3, arg4}) stub := fake.UploadDropletStub fakeReturns := fake.uploadDropletReturns fake.recordInvocation("UploadDroplet", []interface{}{arg1, arg2, arg3, arg4}) @@ -20739,7 +23171,15 @@ func (fake *FakeActor) UploadDropletArgsForCall(i int) (string, string, io.Reade fake.uploadDropletMutex.RLock() defer fake.uploadDropletMutex.RUnlock() argsForCall := fake.uploadDropletArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.Arg1, argsForCall.Arg2, argsForCall.Arg3, argsForCall.Arg4 +} + +func (fake *FakeActor) UploadDropletArgs() []FakeActorUploadDropletArgs { + fake.uploadDropletMutex.RLock() + defer fake.uploadDropletMutex.RUnlock() + args := make([]FakeActorUploadDropletArgs, len(fake.uploadDropletArgsForCall)) + copy(args, fake.uploadDropletArgsForCall) + return args } func (fake *FakeActor) UploadDropletReturns(result1 v7action.Warnings, result2 error) { @@ -20778,9 +23218,18 @@ func (fake *FakeActor) Invocations() map[string][][]interface{} { return copiedInvocations } +func (fake *FakeActor) CallOrder() []string { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + order := make([]string, len(fake.callOrder)) + copy(order, fake.callOrder) + return order +} + func (fake *FakeActor) recordInvocation(key string, args []interface{}) { fake.invocationsMutex.Lock() defer fake.invocationsMutex.Unlock() + fake.callOrder = append(fake.callOrder, key) if fake.invocations == nil { fake.invocations = map[string][][]interface{}{} } diff --git a/doc/service-accounts-poc.md b/doc/service-accounts-poc.md new file mode 100644 index 0000000000..d6702b0ef4 --- /dev/null +++ b/doc/service-accounts-poc.md @@ -0,0 +1,69 @@ +# Service-account commands (RFC lab) + +This branch implements the space-owned service-account proposal against the lab's +CAPI extensions. The API is not yet released upstream; unsupported foundations +return a CAPI error. A minimum API version will be assigned when the API is +standardized rather than treating an existing version as feature support. + +## Create an account + +```sh +cf target -o poc -s service-accounts-e2e +cf create-service-account shared-worker --description "Background workers" +``` + +Creation requires login, a targeted organization and space, and CAPI account +management permission (space manager or platform admin in the local profile). +The request uses the targeted space as the immutable owner. Names are immutable, +foundation-unique, and permanently reserved after deletion; CAPI validates them. + +Output shows the platform-returned client ID, certificate DNS SAN, and provisioning +status. Creating the account does not provision its UAA client, bind an app, or +grant resource roles. Provisioning occurs on first authorized app assignment. + +## List accounts + +Run `cf service-accounts` to list accounts owned by the targeted space. The table +shows name, enabled state, provisioning status, client ID and certificate DNS SAN. +All result pages are retrieved; API warnings and errors are preserved. + +## Lifecycle and app assignment + +```sh +cf service-account shared-worker +cf bind-service-account my-app shared-worker +cf unbind-service-account my-app +cf disable-service-account shared-worker +cf enable-service-account shared-worker +cf delete-service-account shared-worker +``` + +All name resolution is scoped to the targeted space. Bind/unbind and account +lifecycle commands wait for asynchronous CAPI jobs before printing success. +Bind/unbind update the desired assignment only: restart the app explicitly to +apply the new launch identity. Existing certificates and tokens are not revoked. +Binding does not grant resource roles. + +Disabling prevents new token issuance once reconciliation completes; existing +tokens and certificate-only access persist until their normal expiry. Deletion +requires the account to be unused and retains its name reservation permanently. +Deletion asks for confirmation unless `-f` is supplied; this flag skips the prompt, +not CAPI's in-use checks. Explicit account-role UX remains a follow-up. + +Creation, listing and all lifecycle commands are listed in both `cf help` and +`cf help -a`. For this checkout, use the built custom binary or `go run ./main.go` +from `cli/`; the installed stock CLI does not contain these local extensions. + +## Development + +From the lab workspace root: + +```sh +devbox run -- env -C "$PWD/cli" go test ./api/cloudcontroller/ccv3 ./actor/v7action ./command/v7 ./command/common -ginkgo.focus='Service Account|create-service-account' +devbox run -- env -C "$PWD/cli" go test ./resources ./api/cloudcontroller/ccv3 ./actor/v7action ./command/v7 ./command/common +devbox run -- env -C "$PWD/cli" go build -o ../.local/cf-service-accounts . +./.local/cf-service-accounts help create-service-account +``` + +Use separate committed RED/GREEN cycles. Generate changed interface fakes using +the repository-pinned Counterfeiter; do not hand-edit generated output. diff --git a/resources/service_account_resource.go b/resources/service_account_resource.go new file mode 100644 index 0000000000..f1098decf8 --- /dev/null +++ b/resources/service_account_resource.go @@ -0,0 +1,13 @@ +package resources + +// ServiceAccount represents a space-owned Cloud Controller service account. +type ServiceAccount struct { + GUID string `json:"guid,omitempty"` + Name string `json:"name"` + Description string `json:"description,omitempty"` + ClientID string `json:"client_id,omitempty"` + CertificateDNSSAN string `json:"certificate_dns_san,omitempty"` + Enabled bool `json:"enabled,omitempty"` + Status string `json:"status,omitempty"` + Relationships Relationships `json:"relationships,omitempty"` +}