diff --git a/.github/workflows/code-health.yml b/.github/workflows/code-health.yml index aa411d6da6..fab0bf904b 100644 --- a/.github/workflows/code-health.yml +++ b/.github/workflows/code-health.yml @@ -20,19 +20,6 @@ jobs: - uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 with: go-version-file: 'go.mod' - - name: Mock generation - run: make tools generate-mocks - - name: Check for uncommited files - run: | - FILES=$(git ls-files -o -m --directory --exclude-standard --no-empty-directory) - LINES=$(echo "$FILES" | awk 'NF' | wc -l) - if [ "${LINES}" -ne 0 ]; then - echo "Detected files that need to be committed:" - echo "${FILES//^/ }" - echo "" - echo "Mock skeletons are not up-to-date, you may have forgotten to run mockery before committing your changes." - exit 1 - fi - name: Build run: make build unit-test: diff --git a/.mockery.yaml b/.mockery.yaml deleted file mode 100644 index c8deb3094c..0000000000 --- a/.mockery.yaml +++ /dev/null @@ -1,15 +0,0 @@ -with-expecter: true -disable-version-string: true -dir: internal/testutil/mocksvc -outpkg: mocksvc -filename: "{{ .InterfaceName | snakecase }}.go" -mockname: "{{.InterfaceName}}" - -packages: - go.mongodb.org/atlas-sdk/v20231115008/admin: - interfaces: - AtlasSearchApi: - EncryptionAtRestUsingCustomerKeyManagementApi: - TeamsApi: - ProjectsApi: - ClustersApi: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5d2f61b342..3c315a1d8f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -312,7 +312,7 @@ To do this you can: - Helper methods must have their own tests, e.g. `common_advanced_cluster_test.go` has tests for `common_advanced_cluster.go`. - `internal/testutils/acc` contains helper test methods for Acceptance and Migration tests. - Tests that need the provider binary like End-to-End tests don’t belong to the source code packages and go in `test/e2e`. -- [Testify Mock](https://pkg.go.dev/github.com/stretchr/testify/mock) and [Mockery](https://github.com/vektra/mockery) are used for test doubles in unit tests. Mocked interfaces are generated in folder `internal/testutil/mocksvc`. +- [Testify Mock](https://pkg.go.dev/github.com/stretchr/testify/mock) and [Mockery](https://github.com/vektra/mockery) are used for test doubles in Atlas Go SDK unit tests. ### Creating New Resource and Data Sources diff --git a/GNUmakefile b/GNUmakefile index 95bdc47517..93a48189bb 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -18,7 +18,6 @@ VERSION=$(GITTAG:v%=%) LINKER_FLAGS=-s -w -X 'github.com/mongodb/terraform-provider-mongodbatlas/version.ProviderVersion=${VERSION}' GOLANGCI_VERSION=v1.56.2 -MOCKERY_VERSION=v2.42.0 export PATH := $(shell go env GOPATH)/bin:$(PATH) export SHELL := env PATH=$(PATH) /bin/bash @@ -79,7 +78,6 @@ tools: ## Install dev tools go install github.com/terraform-linters/tflint@v0.49.0 go install github.com/rhysd/actionlint/cmd/actionlint@latest go install golang.org/x/tools/go/analysis/passes/fieldalignment/cmd/fieldalignment@latest - go install github.com/vektra/mockery/v2@$(MOCKERY_VERSION) go install github.com/hashicorp/terraform-plugin-docs/cmd/tfplugindocs@latest go install github.com/hashicorp/terraform-plugin-codegen-openapi/cmd/tfplugingen-openapi@latest go install github.com/hashicorp/terraform-plugin-codegen-framework/cmd/tfplugingen-framework@latest @@ -112,10 +110,6 @@ link-git-hooks: ## Install git hooks update-atlas-sdk: ## Update the atlas-sdk dependency ./scripts/update-sdk.sh -.PHONY: generate-mocks -generate-mocks: # uses mockery to generate mocks in folder `internal/testutil/mocksvc` - mockery - # e.g. run: make scaffold resource_name=streamInstance type=resource # - type argument can have the values: `resource`, `data-source`, `plural-data-source`. # details on usage can be found in CONTRIBUTING.md under "Scaffolding initial Code and File Structure" diff --git a/internal/service/advancedcluster/model_advanced_cluster_test.go b/internal/service/advancedcluster/model_advanced_cluster_test.go index dd94ded6c7..cc330a49e4 100644 --- a/internal/service/advancedcluster/model_advanced_cluster_test.go +++ b/internal/service/advancedcluster/model_advanced_cluster_test.go @@ -8,10 +8,10 @@ import ( "github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion" "github.com/mongodb/terraform-provider-mongodbatlas/internal/service/advancedcluster" - "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/mocksvc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "go.mongodb.org/atlas-sdk/v20231115008/admin" + "go.mongodb.org/atlas-sdk/v20231115008/mockadmin" ) var ( @@ -104,7 +104,7 @@ func TestUpgradeRefreshFunc(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - testObject := mocksvc.NewClustersApi(t) + testObject := mockadmin.NewClustersApi(t) testObject.EXPECT().GetCluster(mock.Anything, mock.Anything, mock.Anything).Return(admin.GetClusterApiRequest{ApiService: testObject}).Once() testObject.EXPECT().GetClusterExecute(mock.Anything).Return(tc.mockCluster, tc.mockResponse, tc.mockError).Once() @@ -209,7 +209,7 @@ func TestResourceListAdvancedRefreshFunc(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - testObject := mocksvc.NewClustersApi(t) + testObject := mockadmin.NewClustersApi(t) testObject.EXPECT().ListClusters(mock.Anything, mock.Anything).Return(admin.ListClustersApiRequest{ApiService: testObject}).Once() testObject.EXPECT().ListClustersExecute(mock.Anything).Return(tc.mockCluster, tc.mockResponse, tc.mockError).Once() diff --git a/internal/service/encryptionatrest/resource_encryption_at_rest_test.go b/internal/service/encryptionatrest/resource_encryption_at_rest_test.go index a4170e4e6e..0cf66e4db4 100644 --- a/internal/service/encryptionatrest/resource_encryption_at_rest_test.go +++ b/internal/service/encryptionatrest/resource_encryption_at_rest_test.go @@ -14,10 +14,10 @@ import ( "github.com/mongodb/terraform-provider-mongodbatlas/internal/common/retrystrategy" "github.com/mongodb/terraform-provider-mongodbatlas/internal/service/encryptionatrest" "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/acc" - "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/mocksvc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "go.mongodb.org/atlas-sdk/v20231115008/admin" + "go.mongodb.org/atlas-sdk/v20231115008/mockadmin" ) const ( @@ -546,7 +546,7 @@ func TestResourceMongoDBAtlasEncryptionAtRestCreateRefreshFunc(t *testing.T) { } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - m := mocksvc.NewEncryptionAtRestUsingCustomerKeyManagementApi(t) + m := mockadmin.NewEncryptionAtRestUsingCustomerKeyManagementApi(t) m.EXPECT().UpdateEncryptionAtRest(mock.Anything, mock.Anything, mock.Anything).Return(admin.UpdateEncryptionAtRestApiRequest{ApiService: m}) m.EXPECT().UpdateEncryptionAtRestExecute(mock.Anything).Return(tc.mockResponse, nil, tc.mockError).Once() diff --git a/internal/service/project/resource_project_test.go b/internal/service/project/resource_project_test.go index df6abbd37e..9701a1651a 100644 --- a/internal/service/project/resource_project_test.go +++ b/internal/service/project/resource_project_test.go @@ -15,9 +15,9 @@ import ( "github.com/mongodb/terraform-provider-mongodbatlas/internal/service/project" "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/acc" - "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/mocksvc" "github.com/stretchr/testify/mock" "go.mongodb.org/atlas-sdk/v20231115008/admin" + "go.mongodb.org/atlas-sdk/v20231115008/mockadmin" ) var ( @@ -106,8 +106,8 @@ func TestGetProjectPropsFromAPI(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - teamsMock := mocksvc.NewTeamsApi(t) - projectsMock := mocksvc.NewProjectsApi(t) + teamsMock := mockadmin.NewTeamsApi(t) + projectsMock := mockadmin.NewProjectsApi(t) teamsMock.EXPECT().ListProjectTeams(mock.Anything, mock.Anything).Return(admin.ListProjectTeamsApiRequest{ApiService: teamsMock}) teamsMock.EXPECT().ListProjectTeamsExecute(mock.Anything).Return(tc.teamRoleReponse.TeamRole, tc.teamRoleReponse.HTTPResponse, tc.teamRoleReponse.Err) @@ -218,7 +218,7 @@ func TestUpdateProject(t *testing.T) { for i, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - svc := mocksvc.NewProjectsApi(t) + svc := mockadmin.NewProjectsApi(t) svc.EXPECT().UpdateProject(mock.Anything, mock.Anything, mock.Anything).Return(admin.UpdateProjectApiRequest{ApiService: svc}).Maybe() svc.EXPECT().UpdateProjectExecute(mock.Anything).Return(tc.mockResponses.Project, tc.mockResponses.HTTPResponse, tc.mockResponses.Err).Maybe() @@ -324,7 +324,7 @@ func TestUpdateProjectLimits(t *testing.T) { for i, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - svc := mocksvc.NewProjectsApi(t) + svc := mockadmin.NewProjectsApi(t) svc.EXPECT().DeleteProjectLimit(mock.Anything, mock.Anything, mock.Anything).Return(admin.DeleteProjectLimitApiRequest{ApiService: svc}).Maybe() svc.EXPECT().DeleteProjectLimitExecute(mock.Anything).Return(tc.mockResponses.DeleteProjectLimit, tc.mockResponses.HTTPResponse, tc.mockResponses.Err).Maybe() @@ -417,7 +417,7 @@ func TestUpdateProjectTeams(t *testing.T) { for i, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - svc := mocksvc.NewTeamsApi(t) + svc := mockadmin.NewTeamsApi(t) svc.EXPECT().AddAllTeamsToProject(mock.Anything, mock.Anything, mock.Anything).Return(admin.AddAllTeamsToProjectApiRequest{ApiService: svc}).Maybe() svc.EXPECT().AddAllTeamsToProjectExecute(mock.Anything).Return(nil, nil, nil).Maybe() @@ -477,7 +477,7 @@ func TestResourceProjectDependentsDeletingRefreshFunc(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - svc := mocksvc.NewClustersApi(t) + svc := mockadmin.NewClustersApi(t) svc.EXPECT().ListClusters(mock.Anything, dummyProjectID).Return(admin.ListClustersApiRequest{ApiService: svc}) svc.EXPECT().ListClustersExecute(mock.Anything).Return(tc.mockResponses.AdvancedClusterDescription, tc.mockResponses.HTTPResponse, tc.mockResponses.Err) diff --git a/internal/service/searchdeployment/state_transition_search_deployment_test.go b/internal/service/searchdeployment/state_transition_search_deployment_test.go index 2b91c3af44..b31794cc74 100644 --- a/internal/service/searchdeployment/state_transition_search_deployment_test.go +++ b/internal/service/searchdeployment/state_transition_search_deployment_test.go @@ -10,10 +10,10 @@ import ( "github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion" "github.com/mongodb/terraform-provider-mongodbatlas/internal/common/retrystrategy" "github.com/mongodb/terraform-provider-mongodbatlas/internal/service/searchdeployment" - "github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/mocksvc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "go.mongodb.org/atlas-sdk/v20231115008/admin" + "go.mongodb.org/atlas-sdk/v20231115008/mockadmin" ) var ( @@ -74,7 +74,7 @@ func TestSearchDeploymentStateTransition(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - m := mocksvc.NewAtlasSearchApi(t) + m := mockadmin.NewAtlasSearchApi(t) m.EXPECT().GetAtlasSearchDeployment(mock.Anything, mock.Anything, mock.Anything).Return(admin.GetAtlasSearchDeploymentApiRequest{ApiService: m}) for _, resp := range tc.mockResponses { @@ -117,7 +117,7 @@ func TestSearchDeploymentStateTransitionForDelete(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - m := mocksvc.NewAtlasSearchApi(t) + m := mockadmin.NewAtlasSearchApi(t) m.EXPECT().GetAtlasSearchDeployment(mock.Anything, mock.Anything, mock.Anything).Return(admin.GetAtlasSearchDeploymentApiRequest{ApiService: m}) for _, resp := range tc.mockResponses { diff --git a/internal/testutil/mocksvc/atlas_search_api.go b/internal/testutil/mocksvc/atlas_search_api.go deleted file mode 100644 index 5e805fd76b..0000000000 --- a/internal/testutil/mocksvc/atlas_search_api.go +++ /dev/null @@ -1,1498 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocksvc - -import ( - context "context" - - admin "go.mongodb.org/atlas-sdk/v20231115008/admin" - - http "net/http" - - mock "github.com/stretchr/testify/mock" -) - -// AtlasSearchApi is an autogenerated mock type for the AtlasSearchApi type -type AtlasSearchApi struct { - mock.Mock -} - -type AtlasSearchApi_Expecter struct { - mock *mock.Mock -} - -func (_m *AtlasSearchApi) EXPECT() *AtlasSearchApi_Expecter { - return &AtlasSearchApi_Expecter{mock: &_m.Mock} -} - -// CreateAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName, apiSearchDeploymentRequest -func (_m *AtlasSearchApi) CreateAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest) admin.CreateAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, groupId, clusterName, apiSearchDeploymentRequest) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchDeployment") - } - - var r0 admin.CreateAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.CreateAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, apiSearchDeploymentRequest) - } else { - r0 = ret.Get(0).(admin.CreateAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_CreateAtlasSearchDeployment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchDeployment' -type AtlasSearchApi_CreateAtlasSearchDeployment_Call struct { - *mock.Call -} - -// CreateAtlasSearchDeployment is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}, apiSearchDeploymentRequest interface{}) *AtlasSearchApi_CreateAtlasSearchDeployment_Call { - return &AtlasSearchApi_CreateAtlasSearchDeployment_Call{Call: _e.mock.On("CreateAtlasSearchDeployment", ctx, groupId, clusterName, apiSearchDeploymentRequest)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeployment_Call) Run(run func(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest)) *AtlasSearchApi_CreateAtlasSearchDeployment_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ApiSearchDeploymentRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeployment_Call) Return(_a0 admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeployment_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeployment_Call { - _c.Call.Return(run) - return _c -} - -// CreateAtlasSearchDeploymentExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) CreateAtlasSearchDeploymentExecute(r admin.CreateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchDeploymentExecute") - } - - var r0 *admin.ApiSearchDeploymentResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateAtlasSearchDeploymentApiRequest) *admin.ApiSearchDeploymentResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ApiSearchDeploymentResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateAtlasSearchDeploymentApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateAtlasSearchDeploymentApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchDeploymentExecute' -type AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call struct { - *mock.Call -} - -// CreateAtlasSearchDeploymentExecute is a helper method to define mock.On call -// - r admin.CreateAtlasSearchDeploymentApiRequest -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call { - return &AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("CreateAtlasSearchDeploymentExecute", r)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call) Run(run func(r admin.CreateAtlasSearchDeploymentApiRequest)) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateAtlasSearchDeploymentApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call) Return(_a0 *admin.ApiSearchDeploymentResponse, _a1 *http.Response, _a2 error) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.CreateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_CreateAtlasSearchDeploymentExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) CreateAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.CreateAtlasSearchDeploymentApiParams) admin.CreateAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchDeploymentWithParams") - } - - var r0 admin.CreateAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateAtlasSearchDeploymentApiParams) admin.CreateAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchDeploymentWithParams' -type AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call struct { - *mock.Call -} - -// CreateAtlasSearchDeploymentWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateAtlasSearchDeploymentApiParams -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call { - return &AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("CreateAtlasSearchDeploymentWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateAtlasSearchDeploymentApiParams)) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateAtlasSearchDeploymentApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateAtlasSearchDeploymentApiParams) admin.CreateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_CreateAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(run) - return _c -} - -// CreateAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, clusterSearchIndex -func (_m *AtlasSearchApi) CreateAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, clusterSearchIndex *admin.ClusterSearchIndex) admin.CreateAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, groupId, clusterName, clusterSearchIndex) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchIndex") - } - - var r0 admin.CreateAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ClusterSearchIndex) admin.CreateAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, clusterSearchIndex) - } else { - r0 = ret.Get(0).(admin.CreateAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_CreateAtlasSearchIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchIndex' -type AtlasSearchApi_CreateAtlasSearchIndex_Call struct { - *mock.Call -} - -// CreateAtlasSearchIndex is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - clusterSearchIndex *admin.ClusterSearchIndex -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, clusterSearchIndex interface{}) *AtlasSearchApi_CreateAtlasSearchIndex_Call { - return &AtlasSearchApi_CreateAtlasSearchIndex_Call{Call: _e.mock.On("CreateAtlasSearchIndex", ctx, groupId, clusterName, clusterSearchIndex)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, clusterSearchIndex *admin.ClusterSearchIndex)) *AtlasSearchApi_CreateAtlasSearchIndex_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ClusterSearchIndex)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndex_Call) Return(_a0 admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndex_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, *admin.ClusterSearchIndex) admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndex_Call { - _c.Call.Return(run) - return _c -} - -// CreateAtlasSearchIndexExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) CreateAtlasSearchIndexExecute(r admin.CreateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchIndexExecute") - } - - var r0 *admin.ClusterSearchIndex - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateAtlasSearchIndexApiRequest) *admin.ClusterSearchIndex); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterSearchIndex) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateAtlasSearchIndexApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateAtlasSearchIndexApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_CreateAtlasSearchIndexExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchIndexExecute' -type AtlasSearchApi_CreateAtlasSearchIndexExecute_Call struct { - *mock.Call -} - -// CreateAtlasSearchIndexExecute is a helper method to define mock.On call -// - r admin.CreateAtlasSearchIndexApiRequest -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call { - return &AtlasSearchApi_CreateAtlasSearchIndexExecute_Call{Call: _e.mock.On("CreateAtlasSearchIndexExecute", r)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call) Run(run func(r admin.CreateAtlasSearchIndexApiRequest)) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateAtlasSearchIndexApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call) Return(_a0 *admin.ClusterSearchIndex, _a1 *http.Response, _a2 error) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.CreateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_CreateAtlasSearchIndexExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) CreateAtlasSearchIndexWithParams(ctx context.Context, args *admin.CreateAtlasSearchIndexApiParams) admin.CreateAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateAtlasSearchIndexWithParams") - } - - var r0 admin.CreateAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateAtlasSearchIndexApiParams) admin.CreateAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAtlasSearchIndexWithParams' -type AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call struct { - *mock.Call -} - -// CreateAtlasSearchIndexWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateAtlasSearchIndexApiParams -func (_e *AtlasSearchApi_Expecter) CreateAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call { - return &AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call{Call: _e.mock.On("CreateAtlasSearchIndexWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateAtlasSearchIndexApiParams)) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateAtlasSearchIndexApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call) Return(_a0 admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateAtlasSearchIndexApiParams) admin.CreateAtlasSearchIndexApiRequest) *AtlasSearchApi_CreateAtlasSearchIndexWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName -func (_m *AtlasSearchApi) DeleteAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string) admin.DeleteAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchDeployment") - } - - var r0 admin.DeleteAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.DeleteAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_DeleteAtlasSearchDeployment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchDeployment' -type AtlasSearchApi_DeleteAtlasSearchDeployment_Call struct { - *mock.Call -} - -// DeleteAtlasSearchDeployment is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}) *AtlasSearchApi_DeleteAtlasSearchDeployment_Call { - return &AtlasSearchApi_DeleteAtlasSearchDeployment_Call{Call: _e.mock.On("DeleteAtlasSearchDeployment", ctx, groupId, clusterName)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeployment_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *AtlasSearchApi_DeleteAtlasSearchDeployment_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeployment_Call) Return(_a0 admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeployment_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeployment_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchDeploymentExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) DeleteAtlasSearchDeploymentExecute(r admin.DeleteAtlasSearchDeploymentApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchDeploymentExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchDeploymentApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchDeploymentApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteAtlasSearchDeploymentApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchDeploymentExecute' -type AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call struct { - *mock.Call -} - -// DeleteAtlasSearchDeploymentExecute is a helper method to define mock.On call -// - r admin.DeleteAtlasSearchDeploymentApiRequest -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call { - return &AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("DeleteAtlasSearchDeploymentExecute", r)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call) Run(run func(r admin.DeleteAtlasSearchDeploymentApiRequest)) *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteAtlasSearchDeploymentApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call) Return(_a0 *http.Response, _a1 error) *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.DeleteAtlasSearchDeploymentApiRequest) (*http.Response, error)) *AtlasSearchApi_DeleteAtlasSearchDeploymentExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) DeleteAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.DeleteAtlasSearchDeploymentApiParams) admin.DeleteAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchDeploymentWithParams") - } - - var r0 admin.DeleteAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteAtlasSearchDeploymentApiParams) admin.DeleteAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchDeploymentWithParams' -type AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call struct { - *mock.Call -} - -// DeleteAtlasSearchDeploymentWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteAtlasSearchDeploymentApiParams -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call { - return &AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("DeleteAtlasSearchDeploymentWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteAtlasSearchDeploymentApiParams)) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteAtlasSearchDeploymentApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAtlasSearchDeploymentApiParams) admin.DeleteAtlasSearchDeploymentApiRequest) *AtlasSearchApi_DeleteAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId -func (_m *AtlasSearchApi) DeleteAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string) admin.DeleteAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, groupId, clusterName, indexId) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchIndex") - } - - var r0 admin.DeleteAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, indexId) - } else { - r0 = ret.Get(0).(admin.DeleteAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_DeleteAtlasSearchIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchIndex' -type AtlasSearchApi_DeleteAtlasSearchIndex_Call struct { - *mock.Call -} - -// DeleteAtlasSearchIndex is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - indexId string -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, indexId interface{}) *AtlasSearchApi_DeleteAtlasSearchIndex_Call { - return &AtlasSearchApi_DeleteAtlasSearchIndex_Call{Call: _e.mock.On("DeleteAtlasSearchIndex", ctx, groupId, clusterName, indexId)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, indexId string)) *AtlasSearchApi_DeleteAtlasSearchIndex_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndex_Call) Return(_a0 admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndex_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndex_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchIndexExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) DeleteAtlasSearchIndexExecute(r admin.DeleteAtlasSearchIndexApiRequest) (map[string]interface{}, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchIndexExecute") - } - - var r0 map[string]interface{} - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchIndexApiRequest) (map[string]interface{}, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteAtlasSearchIndexApiRequest) map[string]interface{}); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(map[string]interface{}) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteAtlasSearchIndexApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.DeleteAtlasSearchIndexApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchIndexExecute' -type AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call struct { - *mock.Call -} - -// DeleteAtlasSearchIndexExecute is a helper method to define mock.On call -// - r admin.DeleteAtlasSearchIndexApiRequest -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call { - return &AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call{Call: _e.mock.On("DeleteAtlasSearchIndexExecute", r)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call) Run(run func(r admin.DeleteAtlasSearchIndexApiRequest)) *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteAtlasSearchIndexApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.DeleteAtlasSearchIndexApiRequest) (map[string]interface{}, *http.Response, error)) *AtlasSearchApi_DeleteAtlasSearchIndexExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) DeleteAtlasSearchIndexWithParams(ctx context.Context, args *admin.DeleteAtlasSearchIndexApiParams) admin.DeleteAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteAtlasSearchIndexWithParams") - } - - var r0 admin.DeleteAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteAtlasSearchIndexApiParams) admin.DeleteAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAtlasSearchIndexWithParams' -type AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call struct { - *mock.Call -} - -// DeleteAtlasSearchIndexWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteAtlasSearchIndexApiParams -func (_e *AtlasSearchApi_Expecter) DeleteAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call { - return &AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call{Call: _e.mock.On("DeleteAtlasSearchIndexWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteAtlasSearchIndexApiParams)) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteAtlasSearchIndexApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call) Return(_a0 admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAtlasSearchIndexApiParams) admin.DeleteAtlasSearchIndexApiRequest) *AtlasSearchApi_DeleteAtlasSearchIndexWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName -func (_m *AtlasSearchApi) GetAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string) admin.GetAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchDeployment") - } - - var r0 admin.GetAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.GetAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_GetAtlasSearchDeployment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchDeployment' -type AtlasSearchApi_GetAtlasSearchDeployment_Call struct { - *mock.Call -} - -// GetAtlasSearchDeployment is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}) *AtlasSearchApi_GetAtlasSearchDeployment_Call { - return &AtlasSearchApi_GetAtlasSearchDeployment_Call{Call: _e.mock.On("GetAtlasSearchDeployment", ctx, groupId, clusterName)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeployment_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *AtlasSearchApi_GetAtlasSearchDeployment_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeployment_Call) Return(_a0 admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeployment_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string) admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeployment_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchDeploymentExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) GetAtlasSearchDeploymentExecute(r admin.GetAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchDeploymentExecute") - } - - var r0 *admin.ApiSearchDeploymentResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetAtlasSearchDeploymentApiRequest) *admin.ApiSearchDeploymentResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ApiSearchDeploymentResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetAtlasSearchDeploymentApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetAtlasSearchDeploymentApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchDeploymentExecute' -type AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call struct { - *mock.Call -} - -// GetAtlasSearchDeploymentExecute is a helper method to define mock.On call -// - r admin.GetAtlasSearchDeploymentApiRequest -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call { - return &AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("GetAtlasSearchDeploymentExecute", r)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call) Run(run func(r admin.GetAtlasSearchDeploymentApiRequest)) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetAtlasSearchDeploymentApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call) Return(_a0 *admin.ApiSearchDeploymentResponse, _a1 *http.Response, _a2 error) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.GetAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_GetAtlasSearchDeploymentExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) GetAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.GetAtlasSearchDeploymentApiParams) admin.GetAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchDeploymentWithParams") - } - - var r0 admin.GetAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAtlasSearchDeploymentApiParams) admin.GetAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchDeploymentWithParams' -type AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call struct { - *mock.Call -} - -// GetAtlasSearchDeploymentWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetAtlasSearchDeploymentApiParams -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call { - return &AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("GetAtlasSearchDeploymentWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAtlasSearchDeploymentApiParams)) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetAtlasSearchDeploymentApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAtlasSearchDeploymentApiParams) admin.GetAtlasSearchDeploymentApiRequest) *AtlasSearchApi_GetAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId -func (_m *AtlasSearchApi) GetAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string) admin.GetAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, groupId, clusterName, indexId) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchIndex") - } - - var r0 admin.GetAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, indexId) - } else { - r0 = ret.Get(0).(admin.GetAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_GetAtlasSearchIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchIndex' -type AtlasSearchApi_GetAtlasSearchIndex_Call struct { - *mock.Call -} - -// GetAtlasSearchIndex is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - indexId string -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, indexId interface{}) *AtlasSearchApi_GetAtlasSearchIndex_Call { - return &AtlasSearchApi_GetAtlasSearchIndex_Call{Call: _e.mock.On("GetAtlasSearchIndex", ctx, groupId, clusterName, indexId)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, indexId string)) *AtlasSearchApi_GetAtlasSearchIndex_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndex_Call) Return(_a0 admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndex_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndex_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchIndexExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) GetAtlasSearchIndexExecute(r admin.GetAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchIndexExecute") - } - - var r0 *admin.ClusterSearchIndex - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetAtlasSearchIndexApiRequest) *admin.ClusterSearchIndex); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterSearchIndex) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetAtlasSearchIndexApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetAtlasSearchIndexApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_GetAtlasSearchIndexExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchIndexExecute' -type AtlasSearchApi_GetAtlasSearchIndexExecute_Call struct { - *mock.Call -} - -// GetAtlasSearchIndexExecute is a helper method to define mock.On call -// - r admin.GetAtlasSearchIndexApiRequest -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call { - return &AtlasSearchApi_GetAtlasSearchIndexExecute_Call{Call: _e.mock.On("GetAtlasSearchIndexExecute", r)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexExecute_Call) Run(run func(r admin.GetAtlasSearchIndexApiRequest)) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetAtlasSearchIndexApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexExecute_Call) Return(_a0 *admin.ClusterSearchIndex, _a1 *http.Response, _a2 error) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.GetAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_GetAtlasSearchIndexExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) GetAtlasSearchIndexWithParams(ctx context.Context, args *admin.GetAtlasSearchIndexApiParams) admin.GetAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetAtlasSearchIndexWithParams") - } - - var r0 admin.GetAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAtlasSearchIndexApiParams) admin.GetAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_GetAtlasSearchIndexWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasSearchIndexWithParams' -type AtlasSearchApi_GetAtlasSearchIndexWithParams_Call struct { - *mock.Call -} - -// GetAtlasSearchIndexWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetAtlasSearchIndexApiParams -func (_e *AtlasSearchApi_Expecter) GetAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call { - return &AtlasSearchApi_GetAtlasSearchIndexWithParams_Call{Call: _e.mock.On("GetAtlasSearchIndexWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAtlasSearchIndexApiParams)) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetAtlasSearchIndexApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call) Return(_a0 admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAtlasSearchIndexApiParams) admin.GetAtlasSearchIndexApiRequest) *AtlasSearchApi_GetAtlasSearchIndexWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListAtlasSearchIndexes provides a mock function with given fields: ctx, groupId, clusterName, collectionName, databaseName -func (_m *AtlasSearchApi) ListAtlasSearchIndexes(ctx context.Context, groupId string, clusterName string, collectionName string, databaseName string) admin.ListAtlasSearchIndexesApiRequest { - ret := _m.Called(ctx, groupId, clusterName, collectionName, databaseName) - - if len(ret) == 0 { - panic("no return value specified for ListAtlasSearchIndexes") - } - - var r0 admin.ListAtlasSearchIndexesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) admin.ListAtlasSearchIndexesApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, collectionName, databaseName) - } else { - r0 = ret.Get(0).(admin.ListAtlasSearchIndexesApiRequest) - } - - return r0 -} - -// AtlasSearchApi_ListAtlasSearchIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasSearchIndexes' -type AtlasSearchApi_ListAtlasSearchIndexes_Call struct { - *mock.Call -} - -// ListAtlasSearchIndexes is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - collectionName string -// - databaseName string -func (_e *AtlasSearchApi_Expecter) ListAtlasSearchIndexes(ctx interface{}, groupId interface{}, clusterName interface{}, collectionName interface{}, databaseName interface{}) *AtlasSearchApi_ListAtlasSearchIndexes_Call { - return &AtlasSearchApi_ListAtlasSearchIndexes_Call{Call: _e.mock.On("ListAtlasSearchIndexes", ctx, groupId, clusterName, collectionName, databaseName)} -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexes_Call) Run(run func(ctx context.Context, groupId string, clusterName string, collectionName string, databaseName string)) *AtlasSearchApi_ListAtlasSearchIndexes_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) - }) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexes_Call) Return(_a0 admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexes_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexes_Call) RunAndReturn(run func(context.Context, string, string, string, string) admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexes_Call { - _c.Call.Return(run) - return _c -} - -// ListAtlasSearchIndexesExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) ListAtlasSearchIndexesExecute(r admin.ListAtlasSearchIndexesApiRequest) ([]admin.ClusterSearchIndex, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListAtlasSearchIndexesExecute") - } - - var r0 []admin.ClusterSearchIndex - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListAtlasSearchIndexesApiRequest) ([]admin.ClusterSearchIndex, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListAtlasSearchIndexesApiRequest) []admin.ClusterSearchIndex); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]admin.ClusterSearchIndex) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListAtlasSearchIndexesApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListAtlasSearchIndexesApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_ListAtlasSearchIndexesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasSearchIndexesExecute' -type AtlasSearchApi_ListAtlasSearchIndexesExecute_Call struct { - *mock.Call -} - -// ListAtlasSearchIndexesExecute is a helper method to define mock.On call -// - r admin.ListAtlasSearchIndexesApiRequest -func (_e *AtlasSearchApi_Expecter) ListAtlasSearchIndexesExecute(r interface{}) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call { - return &AtlasSearchApi_ListAtlasSearchIndexesExecute_Call{Call: _e.mock.On("ListAtlasSearchIndexesExecute", r)} -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call) Run(run func(r admin.ListAtlasSearchIndexesApiRequest)) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListAtlasSearchIndexesApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call) Return(_a0 []admin.ClusterSearchIndex, _a1 *http.Response, _a2 error) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call) RunAndReturn(run func(admin.ListAtlasSearchIndexesApiRequest) ([]admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_ListAtlasSearchIndexesExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListAtlasSearchIndexesWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) ListAtlasSearchIndexesWithParams(ctx context.Context, args *admin.ListAtlasSearchIndexesApiParams) admin.ListAtlasSearchIndexesApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListAtlasSearchIndexesWithParams") - } - - var r0 admin.ListAtlasSearchIndexesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAtlasSearchIndexesApiParams) admin.ListAtlasSearchIndexesApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListAtlasSearchIndexesApiRequest) - } - - return r0 -} - -// AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasSearchIndexesWithParams' -type AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call struct { - *mock.Call -} - -// ListAtlasSearchIndexesWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListAtlasSearchIndexesApiParams -func (_e *AtlasSearchApi_Expecter) ListAtlasSearchIndexesWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call { - return &AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call{Call: _e.mock.On("ListAtlasSearchIndexesWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAtlasSearchIndexesApiParams)) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListAtlasSearchIndexesApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call) Return(_a0 admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAtlasSearchIndexesApiParams) admin.ListAtlasSearchIndexesApiRequest) *AtlasSearchApi_ListAtlasSearchIndexesWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchDeployment provides a mock function with given fields: ctx, groupId, clusterName, apiSearchDeploymentRequest -func (_m *AtlasSearchApi) UpdateAtlasSearchDeployment(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest) admin.UpdateAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, groupId, clusterName, apiSearchDeploymentRequest) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchDeployment") - } - - var r0 admin.UpdateAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.UpdateAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, apiSearchDeploymentRequest) - } else { - r0 = ret.Get(0).(admin.UpdateAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_UpdateAtlasSearchDeployment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchDeployment' -type AtlasSearchApi_UpdateAtlasSearchDeployment_Call struct { - *mock.Call -} - -// UpdateAtlasSearchDeployment is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeployment(ctx interface{}, groupId interface{}, clusterName interface{}, apiSearchDeploymentRequest interface{}) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call { - return &AtlasSearchApi_UpdateAtlasSearchDeployment_Call{Call: _e.mock.On("UpdateAtlasSearchDeployment", ctx, groupId, clusterName, apiSearchDeploymentRequest)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeployment_Call) Run(run func(ctx context.Context, groupId string, clusterName string, apiSearchDeploymentRequest *admin.ApiSearchDeploymentRequest)) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ApiSearchDeploymentRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeployment_Call) Return(_a0 admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeployment_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiSearchDeploymentRequest) admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeployment_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchDeploymentExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) UpdateAtlasSearchDeploymentExecute(r admin.UpdateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchDeploymentExecute") - } - - var r0 *admin.ApiSearchDeploymentResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateAtlasSearchDeploymentApiRequest) *admin.ApiSearchDeploymentResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ApiSearchDeploymentResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateAtlasSearchDeploymentApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateAtlasSearchDeploymentApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchDeploymentExecute' -type AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call struct { - *mock.Call -} - -// UpdateAtlasSearchDeploymentExecute is a helper method to define mock.On call -// - r admin.UpdateAtlasSearchDeploymentApiRequest -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeploymentExecute(r interface{}) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call { - return &AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call{Call: _e.mock.On("UpdateAtlasSearchDeploymentExecute", r)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call) Run(run func(r admin.UpdateAtlasSearchDeploymentApiRequest)) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateAtlasSearchDeploymentApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call) Return(_a0 *admin.ApiSearchDeploymentResponse, _a1 *http.Response, _a2 error) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call) RunAndReturn(run func(admin.UpdateAtlasSearchDeploymentApiRequest) (*admin.ApiSearchDeploymentResponse, *http.Response, error)) *AtlasSearchApi_UpdateAtlasSearchDeploymentExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchDeploymentWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) UpdateAtlasSearchDeploymentWithParams(ctx context.Context, args *admin.UpdateAtlasSearchDeploymentApiParams) admin.UpdateAtlasSearchDeploymentApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchDeploymentWithParams") - } - - var r0 admin.UpdateAtlasSearchDeploymentApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateAtlasSearchDeploymentApiParams) admin.UpdateAtlasSearchDeploymentApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateAtlasSearchDeploymentApiRequest) - } - - return r0 -} - -// AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchDeploymentWithParams' -type AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call struct { - *mock.Call -} - -// UpdateAtlasSearchDeploymentWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateAtlasSearchDeploymentApiParams -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchDeploymentWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call { - return &AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call{Call: _e.mock.On("UpdateAtlasSearchDeploymentWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateAtlasSearchDeploymentApiParams)) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateAtlasSearchDeploymentApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call) Return(_a0 admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAtlasSearchDeploymentApiParams) admin.UpdateAtlasSearchDeploymentApiRequest) *AtlasSearchApi_UpdateAtlasSearchDeploymentWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchIndex provides a mock function with given fields: ctx, groupId, clusterName, indexId, clusterSearchIndex -func (_m *AtlasSearchApi) UpdateAtlasSearchIndex(ctx context.Context, groupId string, clusterName string, indexId string, clusterSearchIndex *admin.ClusterSearchIndex) admin.UpdateAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, groupId, clusterName, indexId, clusterSearchIndex) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchIndex") - } - - var r0 admin.UpdateAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.ClusterSearchIndex) admin.UpdateAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, indexId, clusterSearchIndex) - } else { - r0 = ret.Get(0).(admin.UpdateAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_UpdateAtlasSearchIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchIndex' -type AtlasSearchApi_UpdateAtlasSearchIndex_Call struct { - *mock.Call -} - -// UpdateAtlasSearchIndex is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - indexId string -// - clusterSearchIndex *admin.ClusterSearchIndex -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndex(ctx interface{}, groupId interface{}, clusterName interface{}, indexId interface{}, clusterSearchIndex interface{}) *AtlasSearchApi_UpdateAtlasSearchIndex_Call { - return &AtlasSearchApi_UpdateAtlasSearchIndex_Call{Call: _e.mock.On("UpdateAtlasSearchIndex", ctx, groupId, clusterName, indexId, clusterSearchIndex)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, indexId string, clusterSearchIndex *admin.ClusterSearchIndex)) *AtlasSearchApi_UpdateAtlasSearchIndex_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*admin.ClusterSearchIndex)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) Return(_a0 admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndex_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndex_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.ClusterSearchIndex) admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndex_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchIndexExecute provides a mock function with given fields: r -func (_m *AtlasSearchApi) UpdateAtlasSearchIndexExecute(r admin.UpdateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchIndexExecute") - } - - var r0 *admin.ClusterSearchIndex - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateAtlasSearchIndexApiRequest) *admin.ClusterSearchIndex); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterSearchIndex) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateAtlasSearchIndexApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateAtlasSearchIndexApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchIndexExecute' -type AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call struct { - *mock.Call -} - -// UpdateAtlasSearchIndexExecute is a helper method to define mock.On call -// - r admin.UpdateAtlasSearchIndexApiRequest -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndexExecute(r interface{}) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call { - return &AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call{Call: _e.mock.On("UpdateAtlasSearchIndexExecute", r)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call) Run(run func(r admin.UpdateAtlasSearchIndexApiRequest)) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateAtlasSearchIndexApiRequest)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call) Return(_a0 *admin.ClusterSearchIndex, _a1 *http.Response, _a2 error) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call) RunAndReturn(run func(admin.UpdateAtlasSearchIndexApiRequest) (*admin.ClusterSearchIndex, *http.Response, error)) *AtlasSearchApi_UpdateAtlasSearchIndexExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateAtlasSearchIndexWithParams provides a mock function with given fields: ctx, args -func (_m *AtlasSearchApi) UpdateAtlasSearchIndexWithParams(ctx context.Context, args *admin.UpdateAtlasSearchIndexApiParams) admin.UpdateAtlasSearchIndexApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateAtlasSearchIndexWithParams") - } - - var r0 admin.UpdateAtlasSearchIndexApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateAtlasSearchIndexApiParams) admin.UpdateAtlasSearchIndexApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateAtlasSearchIndexApiRequest) - } - - return r0 -} - -// AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAtlasSearchIndexWithParams' -type AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call struct { - *mock.Call -} - -// UpdateAtlasSearchIndexWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateAtlasSearchIndexApiParams -func (_e *AtlasSearchApi_Expecter) UpdateAtlasSearchIndexWithParams(ctx interface{}, args interface{}) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call { - return &AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call{Call: _e.mock.On("UpdateAtlasSearchIndexWithParams", ctx, args)} -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateAtlasSearchIndexApiParams)) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateAtlasSearchIndexApiParams)) - }) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call) Return(_a0 admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAtlasSearchIndexApiParams) admin.UpdateAtlasSearchIndexApiRequest) *AtlasSearchApi_UpdateAtlasSearchIndexWithParams_Call { - _c.Call.Return(run) - return _c -} - -// NewAtlasSearchApi creates a new instance of AtlasSearchApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewAtlasSearchApi(t interface { - mock.TestingT - Cleanup(func()) -}) *AtlasSearchApi { - mock := &AtlasSearchApi{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/testutil/mocksvc/clusters_api.go b/internal/testutil/mocksvc/clusters_api.go deleted file mode 100644 index 897c7f5f47..0000000000 --- a/internal/testutil/mocksvc/clusters_api.go +++ /dev/null @@ -1,2450 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocksvc - -import ( - context "context" - - admin "go.mongodb.org/atlas-sdk/v20231115008/admin" - - http "net/http" - - mock "github.com/stretchr/testify/mock" -) - -// ClustersApi is an autogenerated mock type for the ClustersApi type -type ClustersApi struct { - mock.Mock -} - -type ClustersApi_Expecter struct { - mock *mock.Mock -} - -func (_m *ClustersApi) EXPECT() *ClustersApi_Expecter { - return &ClustersApi_Expecter{mock: &_m.Mock} -} - -// CreateCluster provides a mock function with given fields: ctx, groupId, advancedClusterDescription -func (_m *ClustersApi) CreateCluster(ctx context.Context, groupId string, advancedClusterDescription *admin.AdvancedClusterDescription) admin.CreateClusterApiRequest { - ret := _m.Called(ctx, groupId, advancedClusterDescription) - - if len(ret) == 0 { - panic("no return value specified for CreateCluster") - } - - var r0 admin.CreateClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.AdvancedClusterDescription) admin.CreateClusterApiRequest); ok { - r0 = rf(ctx, groupId, advancedClusterDescription) - } else { - r0 = ret.Get(0).(admin.CreateClusterApiRequest) - } - - return r0 -} - -// ClustersApi_CreateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCluster' -type ClustersApi_CreateCluster_Call struct { - *mock.Call -} - -// CreateCluster is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - advancedClusterDescription *admin.AdvancedClusterDescription -func (_e *ClustersApi_Expecter) CreateCluster(ctx interface{}, groupId interface{}, advancedClusterDescription interface{}) *ClustersApi_CreateCluster_Call { - return &ClustersApi_CreateCluster_Call{Call: _e.mock.On("CreateCluster", ctx, groupId, advancedClusterDescription)} -} - -func (_c *ClustersApi_CreateCluster_Call) Run(run func(ctx context.Context, groupId string, advancedClusterDescription *admin.AdvancedClusterDescription)) *ClustersApi_CreateCluster_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.AdvancedClusterDescription)) - }) - return _c -} - -func (_c *ClustersApi_CreateCluster_Call) Return(_a0 admin.CreateClusterApiRequest) *ClustersApi_CreateCluster_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_CreateCluster_Call) RunAndReturn(run func(context.Context, string, *admin.AdvancedClusterDescription) admin.CreateClusterApiRequest) *ClustersApi_CreateCluster_Call { - _c.Call.Return(run) - return _c -} - -// CreateClusterExecute provides a mock function with given fields: r -func (_m *ClustersApi) CreateClusterExecute(r admin.CreateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateClusterExecute") - } - - var r0 *admin.AdvancedClusterDescription - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateClusterApiRequest) *admin.AdvancedClusterDescription); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.AdvancedClusterDescription) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateClusterApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateClusterApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_CreateClusterExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClusterExecute' -type ClustersApi_CreateClusterExecute_Call struct { - *mock.Call -} - -// CreateClusterExecute is a helper method to define mock.On call -// - r admin.CreateClusterApiRequest -func (_e *ClustersApi_Expecter) CreateClusterExecute(r interface{}) *ClustersApi_CreateClusterExecute_Call { - return &ClustersApi_CreateClusterExecute_Call{Call: _e.mock.On("CreateClusterExecute", r)} -} - -func (_c *ClustersApi_CreateClusterExecute_Call) Run(run func(r admin.CreateClusterApiRequest)) *ClustersApi_CreateClusterExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateClusterApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_CreateClusterExecute_Call) Return(_a0 *admin.AdvancedClusterDescription, _a1 *http.Response, _a2 error) *ClustersApi_CreateClusterExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_CreateClusterExecute_Call) RunAndReturn(run func(admin.CreateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_CreateClusterExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateClusterWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) CreateClusterWithParams(ctx context.Context, args *admin.CreateClusterApiParams) admin.CreateClusterApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateClusterWithParams") - } - - var r0 admin.CreateClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateClusterApiParams) admin.CreateClusterApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateClusterApiRequest) - } - - return r0 -} - -// ClustersApi_CreateClusterWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClusterWithParams' -type ClustersApi_CreateClusterWithParams_Call struct { - *mock.Call -} - -// CreateClusterWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateClusterApiParams -func (_e *ClustersApi_Expecter) CreateClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_CreateClusterWithParams_Call { - return &ClustersApi_CreateClusterWithParams_Call{Call: _e.mock.On("CreateClusterWithParams", ctx, args)} -} - -func (_c *ClustersApi_CreateClusterWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateClusterApiParams)) *ClustersApi_CreateClusterWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateClusterApiParams)) - }) - return _c -} - -func (_c *ClustersApi_CreateClusterWithParams_Call) Return(_a0 admin.CreateClusterApiRequest) *ClustersApi_CreateClusterWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_CreateClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateClusterApiParams) admin.CreateClusterApiRequest) *ClustersApi_CreateClusterWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteCluster provides a mock function with given fields: ctx, groupId, clusterName -func (_m *ClustersApi) DeleteCluster(ctx context.Context, groupId string, clusterName string) admin.DeleteClusterApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for DeleteCluster") - } - - var r0 admin.DeleteClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteClusterApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.DeleteClusterApiRequest) - } - - return r0 -} - -// ClustersApi_DeleteCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCluster' -type ClustersApi_DeleteCluster_Call struct { - *mock.Call -} - -// DeleteCluster is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *ClustersApi_Expecter) DeleteCluster(ctx interface{}, groupId interface{}, clusterName interface{}) *ClustersApi_DeleteCluster_Call { - return &ClustersApi_DeleteCluster_Call{Call: _e.mock.On("DeleteCluster", ctx, groupId, clusterName)} -} - -func (_c *ClustersApi_DeleteCluster_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClustersApi_DeleteCluster_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_DeleteCluster_Call) Return(_a0 admin.DeleteClusterApiRequest) *ClustersApi_DeleteCluster_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_DeleteCluster_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteClusterApiRequest) *ClustersApi_DeleteCluster_Call { - _c.Call.Return(run) - return _c -} - -// DeleteClusterExecute provides a mock function with given fields: r -func (_m *ClustersApi) DeleteClusterExecute(r admin.DeleteClusterApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteClusterExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.DeleteClusterApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteClusterApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteClusterApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// ClustersApi_DeleteClusterExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterExecute' -type ClustersApi_DeleteClusterExecute_Call struct { - *mock.Call -} - -// DeleteClusterExecute is a helper method to define mock.On call -// - r admin.DeleteClusterApiRequest -func (_e *ClustersApi_Expecter) DeleteClusterExecute(r interface{}) *ClustersApi_DeleteClusterExecute_Call { - return &ClustersApi_DeleteClusterExecute_Call{Call: _e.mock.On("DeleteClusterExecute", r)} -} - -func (_c *ClustersApi_DeleteClusterExecute_Call) Run(run func(r admin.DeleteClusterApiRequest)) *ClustersApi_DeleteClusterExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteClusterApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_DeleteClusterExecute_Call) Return(_a0 *http.Response, _a1 error) *ClustersApi_DeleteClusterExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *ClustersApi_DeleteClusterExecute_Call) RunAndReturn(run func(admin.DeleteClusterApiRequest) (*http.Response, error)) *ClustersApi_DeleteClusterExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteClusterWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) DeleteClusterWithParams(ctx context.Context, args *admin.DeleteClusterApiParams) admin.DeleteClusterApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteClusterWithParams") - } - - var r0 admin.DeleteClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteClusterApiParams) admin.DeleteClusterApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteClusterApiRequest) - } - - return r0 -} - -// ClustersApi_DeleteClusterWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClusterWithParams' -type ClustersApi_DeleteClusterWithParams_Call struct { - *mock.Call -} - -// DeleteClusterWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteClusterApiParams -func (_e *ClustersApi_Expecter) DeleteClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_DeleteClusterWithParams_Call { - return &ClustersApi_DeleteClusterWithParams_Call{Call: _e.mock.On("DeleteClusterWithParams", ctx, args)} -} - -func (_c *ClustersApi_DeleteClusterWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteClusterApiParams)) *ClustersApi_DeleteClusterWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteClusterApiParams)) - }) - return _c -} - -func (_c *ClustersApi_DeleteClusterWithParams_Call) Return(_a0 admin.DeleteClusterApiRequest) *ClustersApi_DeleteClusterWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_DeleteClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteClusterApiParams) admin.DeleteClusterApiRequest) *ClustersApi_DeleteClusterWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetCluster provides a mock function with given fields: ctx, groupId, clusterName -func (_m *ClustersApi) GetCluster(ctx context.Context, groupId string, clusterName string) admin.GetClusterApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for GetCluster") - } - - var r0 admin.GetClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetClusterApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.GetClusterApiRequest) - } - - return r0 -} - -// ClustersApi_GetCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCluster' -type ClustersApi_GetCluster_Call struct { - *mock.Call -} - -// GetCluster is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *ClustersApi_Expecter) GetCluster(ctx interface{}, groupId interface{}, clusterName interface{}) *ClustersApi_GetCluster_Call { - return &ClustersApi_GetCluster_Call{Call: _e.mock.On("GetCluster", ctx, groupId, clusterName)} -} - -func (_c *ClustersApi_GetCluster_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClustersApi_GetCluster_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_GetCluster_Call) Return(_a0 admin.GetClusterApiRequest) *ClustersApi_GetCluster_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetCluster_Call) RunAndReturn(run func(context.Context, string, string) admin.GetClusterApiRequest) *ClustersApi_GetCluster_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterAdvancedConfiguration provides a mock function with given fields: ctx, groupId, clusterName -func (_m *ClustersApi) GetClusterAdvancedConfiguration(ctx context.Context, groupId string, clusterName string) admin.GetClusterAdvancedConfigurationApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for GetClusterAdvancedConfiguration") - } - - var r0 admin.GetClusterAdvancedConfigurationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetClusterAdvancedConfigurationApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.GetClusterAdvancedConfigurationApiRequest) - } - - return r0 -} - -// ClustersApi_GetClusterAdvancedConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterAdvancedConfiguration' -type ClustersApi_GetClusterAdvancedConfiguration_Call struct { - *mock.Call -} - -// GetClusterAdvancedConfiguration is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *ClustersApi_Expecter) GetClusterAdvancedConfiguration(ctx interface{}, groupId interface{}, clusterName interface{}) *ClustersApi_GetClusterAdvancedConfiguration_Call { - return &ClustersApi_GetClusterAdvancedConfiguration_Call{Call: _e.mock.On("GetClusterAdvancedConfiguration", ctx, groupId, clusterName)} -} - -func (_c *ClustersApi_GetClusterAdvancedConfiguration_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClustersApi_GetClusterAdvancedConfiguration_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfiguration_Call) Return(_a0 admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfiguration_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfiguration_Call) RunAndReturn(run func(context.Context, string, string) admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfiguration_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterAdvancedConfigurationExecute provides a mock function with given fields: r -func (_m *ClustersApi) GetClusterAdvancedConfigurationExecute(r admin.GetClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetClusterAdvancedConfigurationExecute") - } - - var r0 *admin.ClusterDescriptionProcessArgs - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetClusterAdvancedConfigurationApiRequest) *admin.ClusterDescriptionProcessArgs); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterDescriptionProcessArgs) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetClusterAdvancedConfigurationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetClusterAdvancedConfigurationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_GetClusterAdvancedConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterAdvancedConfigurationExecute' -type ClustersApi_GetClusterAdvancedConfigurationExecute_Call struct { - *mock.Call -} - -// GetClusterAdvancedConfigurationExecute is a helper method to define mock.On call -// - r admin.GetClusterAdvancedConfigurationApiRequest -func (_e *ClustersApi_Expecter) GetClusterAdvancedConfigurationExecute(r interface{}) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call { - return &ClustersApi_GetClusterAdvancedConfigurationExecute_Call{Call: _e.mock.On("GetClusterAdvancedConfigurationExecute", r)} -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationExecute_Call) Run(run func(r admin.GetClusterAdvancedConfigurationApiRequest)) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetClusterAdvancedConfigurationApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationExecute_Call) Return(_a0 *admin.ClusterDescriptionProcessArgs, _a1 *http.Response, _a2 error) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationExecute_Call) RunAndReturn(run func(admin.GetClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)) *ClustersApi_GetClusterAdvancedConfigurationExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterAdvancedConfigurationWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) GetClusterAdvancedConfigurationWithParams(ctx context.Context, args *admin.GetClusterAdvancedConfigurationApiParams) admin.GetClusterAdvancedConfigurationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetClusterAdvancedConfigurationWithParams") - } - - var r0 admin.GetClusterAdvancedConfigurationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetClusterAdvancedConfigurationApiParams) admin.GetClusterAdvancedConfigurationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetClusterAdvancedConfigurationApiRequest) - } - - return r0 -} - -// ClustersApi_GetClusterAdvancedConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterAdvancedConfigurationWithParams' -type ClustersApi_GetClusterAdvancedConfigurationWithParams_Call struct { - *mock.Call -} - -// GetClusterAdvancedConfigurationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetClusterAdvancedConfigurationApiParams -func (_e *ClustersApi_Expecter) GetClusterAdvancedConfigurationWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call { - return &ClustersApi_GetClusterAdvancedConfigurationWithParams_Call{Call: _e.mock.On("GetClusterAdvancedConfigurationWithParams", ctx, args)} -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetClusterAdvancedConfigurationApiParams)) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetClusterAdvancedConfigurationApiParams)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call) Return(_a0 admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterAdvancedConfigurationApiParams) admin.GetClusterAdvancedConfigurationApiRequest) *ClustersApi_GetClusterAdvancedConfigurationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterExecute provides a mock function with given fields: r -func (_m *ClustersApi) GetClusterExecute(r admin.GetClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetClusterExecute") - } - - var r0 *admin.AdvancedClusterDescription - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetClusterApiRequest) *admin.AdvancedClusterDescription); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.AdvancedClusterDescription) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetClusterApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetClusterApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_GetClusterExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterExecute' -type ClustersApi_GetClusterExecute_Call struct { - *mock.Call -} - -// GetClusterExecute is a helper method to define mock.On call -// - r admin.GetClusterApiRequest -func (_e *ClustersApi_Expecter) GetClusterExecute(r interface{}) *ClustersApi_GetClusterExecute_Call { - return &ClustersApi_GetClusterExecute_Call{Call: _e.mock.On("GetClusterExecute", r)} -} - -func (_c *ClustersApi_GetClusterExecute_Call) Run(run func(r admin.GetClusterApiRequest)) *ClustersApi_GetClusterExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetClusterApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterExecute_Call) Return(_a0 *admin.AdvancedClusterDescription, _a1 *http.Response, _a2 error) *ClustersApi_GetClusterExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_GetClusterExecute_Call) RunAndReturn(run func(admin.GetClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_GetClusterExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterStatus provides a mock function with given fields: ctx, groupId, clusterName -func (_m *ClustersApi) GetClusterStatus(ctx context.Context, groupId string, clusterName string) admin.GetClusterStatusApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for GetClusterStatus") - } - - var r0 admin.GetClusterStatusApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetClusterStatusApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.GetClusterStatusApiRequest) - } - - return r0 -} - -// ClustersApi_GetClusterStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterStatus' -type ClustersApi_GetClusterStatus_Call struct { - *mock.Call -} - -// GetClusterStatus is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *ClustersApi_Expecter) GetClusterStatus(ctx interface{}, groupId interface{}, clusterName interface{}) *ClustersApi_GetClusterStatus_Call { - return &ClustersApi_GetClusterStatus_Call{Call: _e.mock.On("GetClusterStatus", ctx, groupId, clusterName)} -} - -func (_c *ClustersApi_GetClusterStatus_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClustersApi_GetClusterStatus_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterStatus_Call) Return(_a0 admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatus_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetClusterStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatus_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterStatusExecute provides a mock function with given fields: r -func (_m *ClustersApi) GetClusterStatusExecute(r admin.GetClusterStatusApiRequest) (*admin.ClusterStatus, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetClusterStatusExecute") - } - - var r0 *admin.ClusterStatus - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetClusterStatusApiRequest) (*admin.ClusterStatus, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetClusterStatusApiRequest) *admin.ClusterStatus); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterStatus) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetClusterStatusApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetClusterStatusApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_GetClusterStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterStatusExecute' -type ClustersApi_GetClusterStatusExecute_Call struct { - *mock.Call -} - -// GetClusterStatusExecute is a helper method to define mock.On call -// - r admin.GetClusterStatusApiRequest -func (_e *ClustersApi_Expecter) GetClusterStatusExecute(r interface{}) *ClustersApi_GetClusterStatusExecute_Call { - return &ClustersApi_GetClusterStatusExecute_Call{Call: _e.mock.On("GetClusterStatusExecute", r)} -} - -func (_c *ClustersApi_GetClusterStatusExecute_Call) Run(run func(r admin.GetClusterStatusApiRequest)) *ClustersApi_GetClusterStatusExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetClusterStatusApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterStatusExecute_Call) Return(_a0 *admin.ClusterStatus, _a1 *http.Response, _a2 error) *ClustersApi_GetClusterStatusExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_GetClusterStatusExecute_Call) RunAndReturn(run func(admin.GetClusterStatusApiRequest) (*admin.ClusterStatus, *http.Response, error)) *ClustersApi_GetClusterStatusExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterStatusWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) GetClusterStatusWithParams(ctx context.Context, args *admin.GetClusterStatusApiParams) admin.GetClusterStatusApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetClusterStatusWithParams") - } - - var r0 admin.GetClusterStatusApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetClusterStatusApiParams) admin.GetClusterStatusApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetClusterStatusApiRequest) - } - - return r0 -} - -// ClustersApi_GetClusterStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterStatusWithParams' -type ClustersApi_GetClusterStatusWithParams_Call struct { - *mock.Call -} - -// GetClusterStatusWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetClusterStatusApiParams -func (_e *ClustersApi_Expecter) GetClusterStatusWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterStatusWithParams_Call { - return &ClustersApi_GetClusterStatusWithParams_Call{Call: _e.mock.On("GetClusterStatusWithParams", ctx, args)} -} - -func (_c *ClustersApi_GetClusterStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetClusterStatusApiParams)) *ClustersApi_GetClusterStatusWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetClusterStatusApiParams)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterStatusWithParams_Call) Return(_a0 admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatusWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetClusterStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterStatusApiParams) admin.GetClusterStatusApiRequest) *ClustersApi_GetClusterStatusWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetClusterWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) GetClusterWithParams(ctx context.Context, args *admin.GetClusterApiParams) admin.GetClusterApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetClusterWithParams") - } - - var r0 admin.GetClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetClusterApiParams) admin.GetClusterApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetClusterApiRequest) - } - - return r0 -} - -// ClustersApi_GetClusterWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClusterWithParams' -type ClustersApi_GetClusterWithParams_Call struct { - *mock.Call -} - -// GetClusterWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetClusterApiParams -func (_e *ClustersApi_Expecter) GetClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_GetClusterWithParams_Call { - return &ClustersApi_GetClusterWithParams_Call{Call: _e.mock.On("GetClusterWithParams", ctx, args)} -} - -func (_c *ClustersApi_GetClusterWithParams_Call) Run(run func(ctx context.Context, args *admin.GetClusterApiParams)) *ClustersApi_GetClusterWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetClusterApiParams)) - }) - return _c -} - -func (_c *ClustersApi_GetClusterWithParams_Call) Return(_a0 admin.GetClusterApiRequest) *ClustersApi_GetClusterWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetClusterApiParams) admin.GetClusterApiRequest) *ClustersApi_GetClusterWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetSampleDatasetLoadStatus provides a mock function with given fields: ctx, groupId, sampleDatasetId -func (_m *ClustersApi) GetSampleDatasetLoadStatus(ctx context.Context, groupId string, sampleDatasetId string) admin.GetSampleDatasetLoadStatusApiRequest { - ret := _m.Called(ctx, groupId, sampleDatasetId) - - if len(ret) == 0 { - panic("no return value specified for GetSampleDatasetLoadStatus") - } - - var r0 admin.GetSampleDatasetLoadStatusApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetSampleDatasetLoadStatusApiRequest); ok { - r0 = rf(ctx, groupId, sampleDatasetId) - } else { - r0 = ret.Get(0).(admin.GetSampleDatasetLoadStatusApiRequest) - } - - return r0 -} - -// ClustersApi_GetSampleDatasetLoadStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSampleDatasetLoadStatus' -type ClustersApi_GetSampleDatasetLoadStatus_Call struct { - *mock.Call -} - -// GetSampleDatasetLoadStatus is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - sampleDatasetId string -func (_e *ClustersApi_Expecter) GetSampleDatasetLoadStatus(ctx interface{}, groupId interface{}, sampleDatasetId interface{}) *ClustersApi_GetSampleDatasetLoadStatus_Call { - return &ClustersApi_GetSampleDatasetLoadStatus_Call{Call: _e.mock.On("GetSampleDatasetLoadStatus", ctx, groupId, sampleDatasetId)} -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatus_Call) Run(run func(ctx context.Context, groupId string, sampleDatasetId string)) *ClustersApi_GetSampleDatasetLoadStatus_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatus_Call) Return(_a0 admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatus_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatus_Call { - _c.Call.Return(run) - return _c -} - -// GetSampleDatasetLoadStatusExecute provides a mock function with given fields: r -func (_m *ClustersApi) GetSampleDatasetLoadStatusExecute(r admin.GetSampleDatasetLoadStatusApiRequest) (*admin.SampleDatasetStatus, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetSampleDatasetLoadStatusExecute") - } - - var r0 *admin.SampleDatasetStatus - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetSampleDatasetLoadStatusApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetSampleDatasetLoadStatusApiRequest) *admin.SampleDatasetStatus); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.SampleDatasetStatus) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetSampleDatasetLoadStatusApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetSampleDatasetLoadStatusApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_GetSampleDatasetLoadStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSampleDatasetLoadStatusExecute' -type ClustersApi_GetSampleDatasetLoadStatusExecute_Call struct { - *mock.Call -} - -// GetSampleDatasetLoadStatusExecute is a helper method to define mock.On call -// - r admin.GetSampleDatasetLoadStatusApiRequest -func (_e *ClustersApi_Expecter) GetSampleDatasetLoadStatusExecute(r interface{}) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call { - return &ClustersApi_GetSampleDatasetLoadStatusExecute_Call{Call: _e.mock.On("GetSampleDatasetLoadStatusExecute", r)} -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusExecute_Call) Run(run func(r admin.GetSampleDatasetLoadStatusApiRequest)) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetSampleDatasetLoadStatusApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusExecute_Call) Return(_a0 *admin.SampleDatasetStatus, _a1 *http.Response, _a2 error) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusExecute_Call) RunAndReturn(run func(admin.GetSampleDatasetLoadStatusApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)) *ClustersApi_GetSampleDatasetLoadStatusExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetSampleDatasetLoadStatusWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) GetSampleDatasetLoadStatusWithParams(ctx context.Context, args *admin.GetSampleDatasetLoadStatusApiParams) admin.GetSampleDatasetLoadStatusApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetSampleDatasetLoadStatusWithParams") - } - - var r0 admin.GetSampleDatasetLoadStatusApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetSampleDatasetLoadStatusApiParams) admin.GetSampleDatasetLoadStatusApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetSampleDatasetLoadStatusApiRequest) - } - - return r0 -} - -// ClustersApi_GetSampleDatasetLoadStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSampleDatasetLoadStatusWithParams' -type ClustersApi_GetSampleDatasetLoadStatusWithParams_Call struct { - *mock.Call -} - -// GetSampleDatasetLoadStatusWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetSampleDatasetLoadStatusApiParams -func (_e *ClustersApi_Expecter) GetSampleDatasetLoadStatusWithParams(ctx interface{}, args interface{}) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call { - return &ClustersApi_GetSampleDatasetLoadStatusWithParams_Call{Call: _e.mock.On("GetSampleDatasetLoadStatusWithParams", ctx, args)} -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetSampleDatasetLoadStatusApiParams)) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetSampleDatasetLoadStatusApiParams)) - }) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call) Return(_a0 admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetSampleDatasetLoadStatusApiParams) admin.GetSampleDatasetLoadStatusApiRequest) *ClustersApi_GetSampleDatasetLoadStatusWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListCloudProviderRegions provides a mock function with given fields: ctx, groupId -func (_m *ClustersApi) ListCloudProviderRegions(ctx context.Context, groupId string) admin.ListCloudProviderRegionsApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListCloudProviderRegions") - } - - var r0 admin.ListCloudProviderRegionsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListCloudProviderRegionsApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListCloudProviderRegionsApiRequest) - } - - return r0 -} - -// ClustersApi_ListCloudProviderRegions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderRegions' -type ClustersApi_ListCloudProviderRegions_Call struct { - *mock.Call -} - -// ListCloudProviderRegions is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ClustersApi_Expecter) ListCloudProviderRegions(ctx interface{}, groupId interface{}) *ClustersApi_ListCloudProviderRegions_Call { - return &ClustersApi_ListCloudProviderRegions_Call{Call: _e.mock.On("ListCloudProviderRegions", ctx, groupId)} -} - -func (_c *ClustersApi_ListCloudProviderRegions_Call) Run(run func(ctx context.Context, groupId string)) *ClustersApi_ListCloudProviderRegions_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegions_Call) Return(_a0 admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegions_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegions_Call) RunAndReturn(run func(context.Context, string) admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegions_Call { - _c.Call.Return(run) - return _c -} - -// ListCloudProviderRegionsExecute provides a mock function with given fields: r -func (_m *ClustersApi) ListCloudProviderRegionsExecute(r admin.ListCloudProviderRegionsApiRequest) (*admin.PaginatedApiAtlasProviderRegions, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListCloudProviderRegionsExecute") - } - - var r0 *admin.PaginatedApiAtlasProviderRegions - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListCloudProviderRegionsApiRequest) (*admin.PaginatedApiAtlasProviderRegions, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListCloudProviderRegionsApiRequest) *admin.PaginatedApiAtlasProviderRegions); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedApiAtlasProviderRegions) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListCloudProviderRegionsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListCloudProviderRegionsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_ListCloudProviderRegionsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderRegionsExecute' -type ClustersApi_ListCloudProviderRegionsExecute_Call struct { - *mock.Call -} - -// ListCloudProviderRegionsExecute is a helper method to define mock.On call -// - r admin.ListCloudProviderRegionsApiRequest -func (_e *ClustersApi_Expecter) ListCloudProviderRegionsExecute(r interface{}) *ClustersApi_ListCloudProviderRegionsExecute_Call { - return &ClustersApi_ListCloudProviderRegionsExecute_Call{Call: _e.mock.On("ListCloudProviderRegionsExecute", r)} -} - -func (_c *ClustersApi_ListCloudProviderRegionsExecute_Call) Run(run func(r admin.ListCloudProviderRegionsApiRequest)) *ClustersApi_ListCloudProviderRegionsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListCloudProviderRegionsApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegionsExecute_Call) Return(_a0 *admin.PaginatedApiAtlasProviderRegions, _a1 *http.Response, _a2 error) *ClustersApi_ListCloudProviderRegionsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegionsExecute_Call) RunAndReturn(run func(admin.ListCloudProviderRegionsApiRequest) (*admin.PaginatedApiAtlasProviderRegions, *http.Response, error)) *ClustersApi_ListCloudProviderRegionsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListCloudProviderRegionsWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) ListCloudProviderRegionsWithParams(ctx context.Context, args *admin.ListCloudProviderRegionsApiParams) admin.ListCloudProviderRegionsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListCloudProviderRegionsWithParams") - } - - var r0 admin.ListCloudProviderRegionsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListCloudProviderRegionsApiParams) admin.ListCloudProviderRegionsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListCloudProviderRegionsApiRequest) - } - - return r0 -} - -// ClustersApi_ListCloudProviderRegionsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderRegionsWithParams' -type ClustersApi_ListCloudProviderRegionsWithParams_Call struct { - *mock.Call -} - -// ListCloudProviderRegionsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListCloudProviderRegionsApiParams -func (_e *ClustersApi_Expecter) ListCloudProviderRegionsWithParams(ctx interface{}, args interface{}) *ClustersApi_ListCloudProviderRegionsWithParams_Call { - return &ClustersApi_ListCloudProviderRegionsWithParams_Call{Call: _e.mock.On("ListCloudProviderRegionsWithParams", ctx, args)} -} - -func (_c *ClustersApi_ListCloudProviderRegionsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListCloudProviderRegionsApiParams)) *ClustersApi_ListCloudProviderRegionsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListCloudProviderRegionsApiParams)) - }) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegionsWithParams_Call) Return(_a0 admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegionsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListCloudProviderRegionsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListCloudProviderRegionsApiParams) admin.ListCloudProviderRegionsApiRequest) *ClustersApi_ListCloudProviderRegionsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListClusters provides a mock function with given fields: ctx, groupId -func (_m *ClustersApi) ListClusters(ctx context.Context, groupId string) admin.ListClustersApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListClusters") - } - - var r0 admin.ListClustersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListClustersApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListClustersApiRequest) - } - - return r0 -} - -// ClustersApi_ListClusters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClusters' -type ClustersApi_ListClusters_Call struct { - *mock.Call -} - -// ListClusters is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ClustersApi_Expecter) ListClusters(ctx interface{}, groupId interface{}) *ClustersApi_ListClusters_Call { - return &ClustersApi_ListClusters_Call{Call: _e.mock.On("ListClusters", ctx, groupId)} -} - -func (_c *ClustersApi_ListClusters_Call) Run(run func(ctx context.Context, groupId string)) *ClustersApi_ListClusters_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ClustersApi_ListClusters_Call) Return(_a0 admin.ListClustersApiRequest) *ClustersApi_ListClusters_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListClusters_Call) RunAndReturn(run func(context.Context, string) admin.ListClustersApiRequest) *ClustersApi_ListClusters_Call { - _c.Call.Return(run) - return _c -} - -// ListClustersExecute provides a mock function with given fields: r -func (_m *ClustersApi) ListClustersExecute(r admin.ListClustersApiRequest) (*admin.PaginatedAdvancedClusterDescription, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListClustersExecute") - } - - var r0 *admin.PaginatedAdvancedClusterDescription - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListClustersApiRequest) (*admin.PaginatedAdvancedClusterDescription, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListClustersApiRequest) *admin.PaginatedAdvancedClusterDescription); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedAdvancedClusterDescription) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListClustersApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListClustersApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_ListClustersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClustersExecute' -type ClustersApi_ListClustersExecute_Call struct { - *mock.Call -} - -// ListClustersExecute is a helper method to define mock.On call -// - r admin.ListClustersApiRequest -func (_e *ClustersApi_Expecter) ListClustersExecute(r interface{}) *ClustersApi_ListClustersExecute_Call { - return &ClustersApi_ListClustersExecute_Call{Call: _e.mock.On("ListClustersExecute", r)} -} - -func (_c *ClustersApi_ListClustersExecute_Call) Run(run func(r admin.ListClustersApiRequest)) *ClustersApi_ListClustersExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListClustersApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_ListClustersExecute_Call) Return(_a0 *admin.PaginatedAdvancedClusterDescription, _a1 *http.Response, _a2 error) *ClustersApi_ListClustersExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_ListClustersExecute_Call) RunAndReturn(run func(admin.ListClustersApiRequest) (*admin.PaginatedAdvancedClusterDescription, *http.Response, error)) *ClustersApi_ListClustersExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListClustersForAllProjects provides a mock function with given fields: ctx -func (_m *ClustersApi) ListClustersForAllProjects(ctx context.Context) admin.ListClustersForAllProjectsApiRequest { - ret := _m.Called(ctx) - - if len(ret) == 0 { - panic("no return value specified for ListClustersForAllProjects") - } - - var r0 admin.ListClustersForAllProjectsApiRequest - if rf, ok := ret.Get(0).(func(context.Context) admin.ListClustersForAllProjectsApiRequest); ok { - r0 = rf(ctx) - } else { - r0 = ret.Get(0).(admin.ListClustersForAllProjectsApiRequest) - } - - return r0 -} - -// ClustersApi_ListClustersForAllProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClustersForAllProjects' -type ClustersApi_ListClustersForAllProjects_Call struct { - *mock.Call -} - -// ListClustersForAllProjects is a helper method to define mock.On call -// - ctx context.Context -func (_e *ClustersApi_Expecter) ListClustersForAllProjects(ctx interface{}) *ClustersApi_ListClustersForAllProjects_Call { - return &ClustersApi_ListClustersForAllProjects_Call{Call: _e.mock.On("ListClustersForAllProjects", ctx)} -} - -func (_c *ClustersApi_ListClustersForAllProjects_Call) Run(run func(ctx context.Context)) *ClustersApi_ListClustersForAllProjects_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context)) - }) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjects_Call) Return(_a0 admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjects_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjects_Call) RunAndReturn(run func(context.Context) admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjects_Call { - _c.Call.Return(run) - return _c -} - -// ListClustersForAllProjectsExecute provides a mock function with given fields: r -func (_m *ClustersApi) ListClustersForAllProjectsExecute(r admin.ListClustersForAllProjectsApiRequest) (*admin.PaginatedOrgGroup, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListClustersForAllProjectsExecute") - } - - var r0 *admin.PaginatedOrgGroup - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListClustersForAllProjectsApiRequest) (*admin.PaginatedOrgGroup, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListClustersForAllProjectsApiRequest) *admin.PaginatedOrgGroup); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedOrgGroup) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListClustersForAllProjectsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListClustersForAllProjectsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_ListClustersForAllProjectsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClustersForAllProjectsExecute' -type ClustersApi_ListClustersForAllProjectsExecute_Call struct { - *mock.Call -} - -// ListClustersForAllProjectsExecute is a helper method to define mock.On call -// - r admin.ListClustersForAllProjectsApiRequest -func (_e *ClustersApi_Expecter) ListClustersForAllProjectsExecute(r interface{}) *ClustersApi_ListClustersForAllProjectsExecute_Call { - return &ClustersApi_ListClustersForAllProjectsExecute_Call{Call: _e.mock.On("ListClustersForAllProjectsExecute", r)} -} - -func (_c *ClustersApi_ListClustersForAllProjectsExecute_Call) Run(run func(r admin.ListClustersForAllProjectsApiRequest)) *ClustersApi_ListClustersForAllProjectsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListClustersForAllProjectsApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjectsExecute_Call) Return(_a0 *admin.PaginatedOrgGroup, _a1 *http.Response, _a2 error) *ClustersApi_ListClustersForAllProjectsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjectsExecute_Call) RunAndReturn(run func(admin.ListClustersForAllProjectsApiRequest) (*admin.PaginatedOrgGroup, *http.Response, error)) *ClustersApi_ListClustersForAllProjectsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListClustersForAllProjectsWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) ListClustersForAllProjectsWithParams(ctx context.Context, args *admin.ListClustersForAllProjectsApiParams) admin.ListClustersForAllProjectsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListClustersForAllProjectsWithParams") - } - - var r0 admin.ListClustersForAllProjectsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListClustersForAllProjectsApiParams) admin.ListClustersForAllProjectsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListClustersForAllProjectsApiRequest) - } - - return r0 -} - -// ClustersApi_ListClustersForAllProjectsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClustersForAllProjectsWithParams' -type ClustersApi_ListClustersForAllProjectsWithParams_Call struct { - *mock.Call -} - -// ListClustersForAllProjectsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListClustersForAllProjectsApiParams -func (_e *ClustersApi_Expecter) ListClustersForAllProjectsWithParams(ctx interface{}, args interface{}) *ClustersApi_ListClustersForAllProjectsWithParams_Call { - return &ClustersApi_ListClustersForAllProjectsWithParams_Call{Call: _e.mock.On("ListClustersForAllProjectsWithParams", ctx, args)} -} - -func (_c *ClustersApi_ListClustersForAllProjectsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListClustersForAllProjectsApiParams)) *ClustersApi_ListClustersForAllProjectsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListClustersForAllProjectsApiParams)) - }) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjectsWithParams_Call) Return(_a0 admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjectsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListClustersForAllProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListClustersForAllProjectsApiParams) admin.ListClustersForAllProjectsApiRequest) *ClustersApi_ListClustersForAllProjectsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListClustersWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) ListClustersWithParams(ctx context.Context, args *admin.ListClustersApiParams) admin.ListClustersApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListClustersWithParams") - } - - var r0 admin.ListClustersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListClustersApiParams) admin.ListClustersApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListClustersApiRequest) - } - - return r0 -} - -// ClustersApi_ListClustersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClustersWithParams' -type ClustersApi_ListClustersWithParams_Call struct { - *mock.Call -} - -// ListClustersWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListClustersApiParams -func (_e *ClustersApi_Expecter) ListClustersWithParams(ctx interface{}, args interface{}) *ClustersApi_ListClustersWithParams_Call { - return &ClustersApi_ListClustersWithParams_Call{Call: _e.mock.On("ListClustersWithParams", ctx, args)} -} - -func (_c *ClustersApi_ListClustersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListClustersApiParams)) *ClustersApi_ListClustersWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListClustersApiParams)) - }) - return _c -} - -func (_c *ClustersApi_ListClustersWithParams_Call) Return(_a0 admin.ListClustersApiRequest) *ClustersApi_ListClustersWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_ListClustersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListClustersApiParams) admin.ListClustersApiRequest) *ClustersApi_ListClustersWithParams_Call { - _c.Call.Return(run) - return _c -} - -// LoadSampleDataset provides a mock function with given fields: ctx, groupId, name -func (_m *ClustersApi) LoadSampleDataset(ctx context.Context, groupId string, name string) admin.LoadSampleDatasetApiRequest { - ret := _m.Called(ctx, groupId, name) - - if len(ret) == 0 { - panic("no return value specified for LoadSampleDataset") - } - - var r0 admin.LoadSampleDatasetApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.LoadSampleDatasetApiRequest); ok { - r0 = rf(ctx, groupId, name) - } else { - r0 = ret.Get(0).(admin.LoadSampleDatasetApiRequest) - } - - return r0 -} - -// ClustersApi_LoadSampleDataset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadSampleDataset' -type ClustersApi_LoadSampleDataset_Call struct { - *mock.Call -} - -// LoadSampleDataset is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - name string -func (_e *ClustersApi_Expecter) LoadSampleDataset(ctx interface{}, groupId interface{}, name interface{}) *ClustersApi_LoadSampleDataset_Call { - return &ClustersApi_LoadSampleDataset_Call{Call: _e.mock.On("LoadSampleDataset", ctx, groupId, name)} -} - -func (_c *ClustersApi_LoadSampleDataset_Call) Run(run func(ctx context.Context, groupId string, name string)) *ClustersApi_LoadSampleDataset_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_LoadSampleDataset_Call) Return(_a0 admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDataset_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_LoadSampleDataset_Call) RunAndReturn(run func(context.Context, string, string) admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDataset_Call { - _c.Call.Return(run) - return _c -} - -// LoadSampleDatasetExecute provides a mock function with given fields: r -func (_m *ClustersApi) LoadSampleDatasetExecute(r admin.LoadSampleDatasetApiRequest) (*admin.SampleDatasetStatus, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for LoadSampleDatasetExecute") - } - - var r0 *admin.SampleDatasetStatus - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.LoadSampleDatasetApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.LoadSampleDatasetApiRequest) *admin.SampleDatasetStatus); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.SampleDatasetStatus) - } - } - - if rf, ok := ret.Get(1).(func(admin.LoadSampleDatasetApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.LoadSampleDatasetApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_LoadSampleDatasetExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadSampleDatasetExecute' -type ClustersApi_LoadSampleDatasetExecute_Call struct { - *mock.Call -} - -// LoadSampleDatasetExecute is a helper method to define mock.On call -// - r admin.LoadSampleDatasetApiRequest -func (_e *ClustersApi_Expecter) LoadSampleDatasetExecute(r interface{}) *ClustersApi_LoadSampleDatasetExecute_Call { - return &ClustersApi_LoadSampleDatasetExecute_Call{Call: _e.mock.On("LoadSampleDatasetExecute", r)} -} - -func (_c *ClustersApi_LoadSampleDatasetExecute_Call) Run(run func(r admin.LoadSampleDatasetApiRequest)) *ClustersApi_LoadSampleDatasetExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.LoadSampleDatasetApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_LoadSampleDatasetExecute_Call) Return(_a0 *admin.SampleDatasetStatus, _a1 *http.Response, _a2 error) *ClustersApi_LoadSampleDatasetExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_LoadSampleDatasetExecute_Call) RunAndReturn(run func(admin.LoadSampleDatasetApiRequest) (*admin.SampleDatasetStatus, *http.Response, error)) *ClustersApi_LoadSampleDatasetExecute_Call { - _c.Call.Return(run) - return _c -} - -// LoadSampleDatasetWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) LoadSampleDatasetWithParams(ctx context.Context, args *admin.LoadSampleDatasetApiParams) admin.LoadSampleDatasetApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for LoadSampleDatasetWithParams") - } - - var r0 admin.LoadSampleDatasetApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.LoadSampleDatasetApiParams) admin.LoadSampleDatasetApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.LoadSampleDatasetApiRequest) - } - - return r0 -} - -// ClustersApi_LoadSampleDatasetWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadSampleDatasetWithParams' -type ClustersApi_LoadSampleDatasetWithParams_Call struct { - *mock.Call -} - -// LoadSampleDatasetWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.LoadSampleDatasetApiParams -func (_e *ClustersApi_Expecter) LoadSampleDatasetWithParams(ctx interface{}, args interface{}) *ClustersApi_LoadSampleDatasetWithParams_Call { - return &ClustersApi_LoadSampleDatasetWithParams_Call{Call: _e.mock.On("LoadSampleDatasetWithParams", ctx, args)} -} - -func (_c *ClustersApi_LoadSampleDatasetWithParams_Call) Run(run func(ctx context.Context, args *admin.LoadSampleDatasetApiParams)) *ClustersApi_LoadSampleDatasetWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.LoadSampleDatasetApiParams)) - }) - return _c -} - -func (_c *ClustersApi_LoadSampleDatasetWithParams_Call) Return(_a0 admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDatasetWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_LoadSampleDatasetWithParams_Call) RunAndReturn(run func(context.Context, *admin.LoadSampleDatasetApiParams) admin.LoadSampleDatasetApiRequest) *ClustersApi_LoadSampleDatasetWithParams_Call { - _c.Call.Return(run) - return _c -} - -// TestFailover provides a mock function with given fields: ctx, groupId, clusterName -func (_m *ClustersApi) TestFailover(ctx context.Context, groupId string, clusterName string) admin.TestFailoverApiRequest { - ret := _m.Called(ctx, groupId, clusterName) - - if len(ret) == 0 { - panic("no return value specified for TestFailover") - } - - var r0 admin.TestFailoverApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.TestFailoverApiRequest); ok { - r0 = rf(ctx, groupId, clusterName) - } else { - r0 = ret.Get(0).(admin.TestFailoverApiRequest) - } - - return r0 -} - -// ClustersApi_TestFailover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestFailover' -type ClustersApi_TestFailover_Call struct { - *mock.Call -} - -// TestFailover is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -func (_e *ClustersApi_Expecter) TestFailover(ctx interface{}, groupId interface{}, clusterName interface{}) *ClustersApi_TestFailover_Call { - return &ClustersApi_TestFailover_Call{Call: _e.mock.On("TestFailover", ctx, groupId, clusterName)} -} - -func (_c *ClustersApi_TestFailover_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClustersApi_TestFailover_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ClustersApi_TestFailover_Call) Return(_a0 admin.TestFailoverApiRequest) *ClustersApi_TestFailover_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_TestFailover_Call) RunAndReturn(run func(context.Context, string, string) admin.TestFailoverApiRequest) *ClustersApi_TestFailover_Call { - _c.Call.Return(run) - return _c -} - -// TestFailoverExecute provides a mock function with given fields: r -func (_m *ClustersApi) TestFailoverExecute(r admin.TestFailoverApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for TestFailoverExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.TestFailoverApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.TestFailoverApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.TestFailoverApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// ClustersApi_TestFailoverExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestFailoverExecute' -type ClustersApi_TestFailoverExecute_Call struct { - *mock.Call -} - -// TestFailoverExecute is a helper method to define mock.On call -// - r admin.TestFailoverApiRequest -func (_e *ClustersApi_Expecter) TestFailoverExecute(r interface{}) *ClustersApi_TestFailoverExecute_Call { - return &ClustersApi_TestFailoverExecute_Call{Call: _e.mock.On("TestFailoverExecute", r)} -} - -func (_c *ClustersApi_TestFailoverExecute_Call) Run(run func(r admin.TestFailoverApiRequest)) *ClustersApi_TestFailoverExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.TestFailoverApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_TestFailoverExecute_Call) Return(_a0 *http.Response, _a1 error) *ClustersApi_TestFailoverExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *ClustersApi_TestFailoverExecute_Call) RunAndReturn(run func(admin.TestFailoverApiRequest) (*http.Response, error)) *ClustersApi_TestFailoverExecute_Call { - _c.Call.Return(run) - return _c -} - -// TestFailoverWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) TestFailoverWithParams(ctx context.Context, args *admin.TestFailoverApiParams) admin.TestFailoverApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for TestFailoverWithParams") - } - - var r0 admin.TestFailoverApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.TestFailoverApiParams) admin.TestFailoverApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.TestFailoverApiRequest) - } - - return r0 -} - -// ClustersApi_TestFailoverWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestFailoverWithParams' -type ClustersApi_TestFailoverWithParams_Call struct { - *mock.Call -} - -// TestFailoverWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.TestFailoverApiParams -func (_e *ClustersApi_Expecter) TestFailoverWithParams(ctx interface{}, args interface{}) *ClustersApi_TestFailoverWithParams_Call { - return &ClustersApi_TestFailoverWithParams_Call{Call: _e.mock.On("TestFailoverWithParams", ctx, args)} -} - -func (_c *ClustersApi_TestFailoverWithParams_Call) Run(run func(ctx context.Context, args *admin.TestFailoverApiParams)) *ClustersApi_TestFailoverWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.TestFailoverApiParams)) - }) - return _c -} - -func (_c *ClustersApi_TestFailoverWithParams_Call) Return(_a0 admin.TestFailoverApiRequest) *ClustersApi_TestFailoverWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_TestFailoverWithParams_Call) RunAndReturn(run func(context.Context, *admin.TestFailoverApiParams) admin.TestFailoverApiRequest) *ClustersApi_TestFailoverWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateCluster provides a mock function with given fields: ctx, groupId, clusterName, advancedClusterDescription -func (_m *ClustersApi) UpdateCluster(ctx context.Context, groupId string, clusterName string, advancedClusterDescription *admin.AdvancedClusterDescription) admin.UpdateClusterApiRequest { - ret := _m.Called(ctx, groupId, clusterName, advancedClusterDescription) - - if len(ret) == 0 { - panic("no return value specified for UpdateCluster") - } - - var r0 admin.UpdateClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.AdvancedClusterDescription) admin.UpdateClusterApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, advancedClusterDescription) - } else { - r0 = ret.Get(0).(admin.UpdateClusterApiRequest) - } - - return r0 -} - -// ClustersApi_UpdateCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCluster' -type ClustersApi_UpdateCluster_Call struct { - *mock.Call -} - -// UpdateCluster is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - advancedClusterDescription *admin.AdvancedClusterDescription -func (_e *ClustersApi_Expecter) UpdateCluster(ctx interface{}, groupId interface{}, clusterName interface{}, advancedClusterDescription interface{}) *ClustersApi_UpdateCluster_Call { - return &ClustersApi_UpdateCluster_Call{Call: _e.mock.On("UpdateCluster", ctx, groupId, clusterName, advancedClusterDescription)} -} - -func (_c *ClustersApi_UpdateCluster_Call) Run(run func(ctx context.Context, groupId string, clusterName string, advancedClusterDescription *admin.AdvancedClusterDescription)) *ClustersApi_UpdateCluster_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.AdvancedClusterDescription)) - }) - return _c -} - -func (_c *ClustersApi_UpdateCluster_Call) Return(_a0 admin.UpdateClusterApiRequest) *ClustersApi_UpdateCluster_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpdateCluster_Call) RunAndReturn(run func(context.Context, string, string, *admin.AdvancedClusterDescription) admin.UpdateClusterApiRequest) *ClustersApi_UpdateCluster_Call { - _c.Call.Return(run) - return _c -} - -// UpdateClusterAdvancedConfiguration provides a mock function with given fields: ctx, groupId, clusterName, clusterDescriptionProcessArgs -func (_m *ClustersApi) UpdateClusterAdvancedConfiguration(ctx context.Context, groupId string, clusterName string, clusterDescriptionProcessArgs *admin.ClusterDescriptionProcessArgs) admin.UpdateClusterAdvancedConfigurationApiRequest { - ret := _m.Called(ctx, groupId, clusterName, clusterDescriptionProcessArgs) - - if len(ret) == 0 { - panic("no return value specified for UpdateClusterAdvancedConfiguration") - } - - var r0 admin.UpdateClusterAdvancedConfigurationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ClusterDescriptionProcessArgs) admin.UpdateClusterAdvancedConfigurationApiRequest); ok { - r0 = rf(ctx, groupId, clusterName, clusterDescriptionProcessArgs) - } else { - r0 = ret.Get(0).(admin.UpdateClusterAdvancedConfigurationApiRequest) - } - - return r0 -} - -// ClustersApi_UpdateClusterAdvancedConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterAdvancedConfiguration' -type ClustersApi_UpdateClusterAdvancedConfiguration_Call struct { - *mock.Call -} - -// UpdateClusterAdvancedConfiguration is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - clusterName string -// - clusterDescriptionProcessArgs *admin.ClusterDescriptionProcessArgs -func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfiguration(ctx interface{}, groupId interface{}, clusterName interface{}, clusterDescriptionProcessArgs interface{}) *ClustersApi_UpdateClusterAdvancedConfiguration_Call { - return &ClustersApi_UpdateClusterAdvancedConfiguration_Call{Call: _e.mock.On("UpdateClusterAdvancedConfiguration", ctx, groupId, clusterName, clusterDescriptionProcessArgs)} -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfiguration_Call) Run(run func(ctx context.Context, groupId string, clusterName string, clusterDescriptionProcessArgs *admin.ClusterDescriptionProcessArgs)) *ClustersApi_UpdateClusterAdvancedConfiguration_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ClusterDescriptionProcessArgs)) - }) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfiguration_Call) Return(_a0 admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfiguration_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfiguration_Call) RunAndReturn(run func(context.Context, string, string, *admin.ClusterDescriptionProcessArgs) admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfiguration_Call { - _c.Call.Return(run) - return _c -} - -// UpdateClusterAdvancedConfigurationExecute provides a mock function with given fields: r -func (_m *ClustersApi) UpdateClusterAdvancedConfigurationExecute(r admin.UpdateClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateClusterAdvancedConfigurationExecute") - } - - var r0 *admin.ClusterDescriptionProcessArgs - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateClusterAdvancedConfigurationApiRequest) *admin.ClusterDescriptionProcessArgs); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ClusterDescriptionProcessArgs) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateClusterAdvancedConfigurationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateClusterAdvancedConfigurationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterAdvancedConfigurationExecute' -type ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call struct { - *mock.Call -} - -// UpdateClusterAdvancedConfigurationExecute is a helper method to define mock.On call -// - r admin.UpdateClusterAdvancedConfigurationApiRequest -func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfigurationExecute(r interface{}) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call { - return &ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call{Call: _e.mock.On("UpdateClusterAdvancedConfigurationExecute", r)} -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call) Run(run func(r admin.UpdateClusterAdvancedConfigurationApiRequest)) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateClusterAdvancedConfigurationApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call) Return(_a0 *admin.ClusterDescriptionProcessArgs, _a1 *http.Response, _a2 error) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call) RunAndReturn(run func(admin.UpdateClusterAdvancedConfigurationApiRequest) (*admin.ClusterDescriptionProcessArgs, *http.Response, error)) *ClustersApi_UpdateClusterAdvancedConfigurationExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateClusterAdvancedConfigurationWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) UpdateClusterAdvancedConfigurationWithParams(ctx context.Context, args *admin.UpdateClusterAdvancedConfigurationApiParams) admin.UpdateClusterAdvancedConfigurationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateClusterAdvancedConfigurationWithParams") - } - - var r0 admin.UpdateClusterAdvancedConfigurationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateClusterAdvancedConfigurationApiParams) admin.UpdateClusterAdvancedConfigurationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateClusterAdvancedConfigurationApiRequest) - } - - return r0 -} - -// ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterAdvancedConfigurationWithParams' -type ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call struct { - *mock.Call -} - -// UpdateClusterAdvancedConfigurationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateClusterAdvancedConfigurationApiParams -func (_e *ClustersApi_Expecter) UpdateClusterAdvancedConfigurationWithParams(ctx interface{}, args interface{}) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call { - return &ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call{Call: _e.mock.On("UpdateClusterAdvancedConfigurationWithParams", ctx, args)} -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateClusterAdvancedConfigurationApiParams)) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateClusterAdvancedConfigurationApiParams)) - }) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call) Return(_a0 admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateClusterAdvancedConfigurationApiParams) admin.UpdateClusterAdvancedConfigurationApiRequest) *ClustersApi_UpdateClusterAdvancedConfigurationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateClusterExecute provides a mock function with given fields: r -func (_m *ClustersApi) UpdateClusterExecute(r admin.UpdateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateClusterExecute") - } - - var r0 *admin.AdvancedClusterDescription - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateClusterApiRequest) *admin.AdvancedClusterDescription); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.AdvancedClusterDescription) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateClusterApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateClusterApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_UpdateClusterExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterExecute' -type ClustersApi_UpdateClusterExecute_Call struct { - *mock.Call -} - -// UpdateClusterExecute is a helper method to define mock.On call -// - r admin.UpdateClusterApiRequest -func (_e *ClustersApi_Expecter) UpdateClusterExecute(r interface{}) *ClustersApi_UpdateClusterExecute_Call { - return &ClustersApi_UpdateClusterExecute_Call{Call: _e.mock.On("UpdateClusterExecute", r)} -} - -func (_c *ClustersApi_UpdateClusterExecute_Call) Run(run func(r admin.UpdateClusterApiRequest)) *ClustersApi_UpdateClusterExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateClusterApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_UpdateClusterExecute_Call) Return(_a0 *admin.AdvancedClusterDescription, _a1 *http.Response, _a2 error) *ClustersApi_UpdateClusterExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_UpdateClusterExecute_Call) RunAndReturn(run func(admin.UpdateClusterApiRequest) (*admin.AdvancedClusterDescription, *http.Response, error)) *ClustersApi_UpdateClusterExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateClusterWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) UpdateClusterWithParams(ctx context.Context, args *admin.UpdateClusterApiParams) admin.UpdateClusterApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateClusterWithParams") - } - - var r0 admin.UpdateClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateClusterApiParams) admin.UpdateClusterApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateClusterApiRequest) - } - - return r0 -} - -// ClustersApi_UpdateClusterWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClusterWithParams' -type ClustersApi_UpdateClusterWithParams_Call struct { - *mock.Call -} - -// UpdateClusterWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateClusterApiParams -func (_e *ClustersApi_Expecter) UpdateClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_UpdateClusterWithParams_Call { - return &ClustersApi_UpdateClusterWithParams_Call{Call: _e.mock.On("UpdateClusterWithParams", ctx, args)} -} - -func (_c *ClustersApi_UpdateClusterWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateClusterApiParams)) *ClustersApi_UpdateClusterWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateClusterApiParams)) - }) - return _c -} - -func (_c *ClustersApi_UpdateClusterWithParams_Call) Return(_a0 admin.UpdateClusterApiRequest) *ClustersApi_UpdateClusterWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpdateClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateClusterApiParams) admin.UpdateClusterApiRequest) *ClustersApi_UpdateClusterWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedCluster provides a mock function with given fields: ctx, groupId, legacyAtlasTenantClusterUpgradeRequest -func (_m *ClustersApi) UpgradeSharedCluster(ctx context.Context, groupId string, legacyAtlasTenantClusterUpgradeRequest *admin.LegacyAtlasTenantClusterUpgradeRequest) admin.UpgradeSharedClusterApiRequest { - ret := _m.Called(ctx, groupId, legacyAtlasTenantClusterUpgradeRequest) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedCluster") - } - - var r0 admin.UpgradeSharedClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LegacyAtlasTenantClusterUpgradeRequest) admin.UpgradeSharedClusterApiRequest); ok { - r0 = rf(ctx, groupId, legacyAtlasTenantClusterUpgradeRequest) - } else { - r0 = ret.Get(0).(admin.UpgradeSharedClusterApiRequest) - } - - return r0 -} - -// ClustersApi_UpgradeSharedCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedCluster' -type ClustersApi_UpgradeSharedCluster_Call struct { - *mock.Call -} - -// UpgradeSharedCluster is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - legacyAtlasTenantClusterUpgradeRequest *admin.LegacyAtlasTenantClusterUpgradeRequest -func (_e *ClustersApi_Expecter) UpgradeSharedCluster(ctx interface{}, groupId interface{}, legacyAtlasTenantClusterUpgradeRequest interface{}) *ClustersApi_UpgradeSharedCluster_Call { - return &ClustersApi_UpgradeSharedCluster_Call{Call: _e.mock.On("UpgradeSharedCluster", ctx, groupId, legacyAtlasTenantClusterUpgradeRequest)} -} - -func (_c *ClustersApi_UpgradeSharedCluster_Call) Run(run func(ctx context.Context, groupId string, legacyAtlasTenantClusterUpgradeRequest *admin.LegacyAtlasTenantClusterUpgradeRequest)) *ClustersApi_UpgradeSharedCluster_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.LegacyAtlasTenantClusterUpgradeRequest)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedCluster_Call) Return(_a0 admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedCluster_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpgradeSharedCluster_Call) RunAndReturn(run func(context.Context, string, *admin.LegacyAtlasTenantClusterUpgradeRequest) admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedCluster_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedClusterExecute provides a mock function with given fields: r -func (_m *ClustersApi) UpgradeSharedClusterExecute(r admin.UpgradeSharedClusterApiRequest) (*admin.LegacyAtlasCluster, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedClusterExecute") - } - - var r0 *admin.LegacyAtlasCluster - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpgradeSharedClusterApiRequest) (*admin.LegacyAtlasCluster, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpgradeSharedClusterApiRequest) *admin.LegacyAtlasCluster); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.LegacyAtlasCluster) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpgradeSharedClusterApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpgradeSharedClusterApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_UpgradeSharedClusterExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedClusterExecute' -type ClustersApi_UpgradeSharedClusterExecute_Call struct { - *mock.Call -} - -// UpgradeSharedClusterExecute is a helper method to define mock.On call -// - r admin.UpgradeSharedClusterApiRequest -func (_e *ClustersApi_Expecter) UpgradeSharedClusterExecute(r interface{}) *ClustersApi_UpgradeSharedClusterExecute_Call { - return &ClustersApi_UpgradeSharedClusterExecute_Call{Call: _e.mock.On("UpgradeSharedClusterExecute", r)} -} - -func (_c *ClustersApi_UpgradeSharedClusterExecute_Call) Run(run func(r admin.UpgradeSharedClusterApiRequest)) *ClustersApi_UpgradeSharedClusterExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpgradeSharedClusterApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterExecute_Call) Return(_a0 *admin.LegacyAtlasCluster, _a1 *http.Response, _a2 error) *ClustersApi_UpgradeSharedClusterExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterExecute_Call) RunAndReturn(run func(admin.UpgradeSharedClusterApiRequest) (*admin.LegacyAtlasCluster, *http.Response, error)) *ClustersApi_UpgradeSharedClusterExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedClusterToServerless provides a mock function with given fields: ctx, groupId, serverlessInstanceDescription -func (_m *ClustersApi) UpgradeSharedClusterToServerless(ctx context.Context, groupId string, serverlessInstanceDescription *admin.ServerlessInstanceDescription) admin.UpgradeSharedClusterToServerlessApiRequest { - ret := _m.Called(ctx, groupId, serverlessInstanceDescription) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedClusterToServerless") - } - - var r0 admin.UpgradeSharedClusterToServerlessApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.ServerlessInstanceDescription) admin.UpgradeSharedClusterToServerlessApiRequest); ok { - r0 = rf(ctx, groupId, serverlessInstanceDescription) - } else { - r0 = ret.Get(0).(admin.UpgradeSharedClusterToServerlessApiRequest) - } - - return r0 -} - -// ClustersApi_UpgradeSharedClusterToServerless_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedClusterToServerless' -type ClustersApi_UpgradeSharedClusterToServerless_Call struct { - *mock.Call -} - -// UpgradeSharedClusterToServerless is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - serverlessInstanceDescription *admin.ServerlessInstanceDescription -func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerless(ctx interface{}, groupId interface{}, serverlessInstanceDescription interface{}) *ClustersApi_UpgradeSharedClusterToServerless_Call { - return &ClustersApi_UpgradeSharedClusterToServerless_Call{Call: _e.mock.On("UpgradeSharedClusterToServerless", ctx, groupId, serverlessInstanceDescription)} -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerless_Call) Run(run func(ctx context.Context, groupId string, serverlessInstanceDescription *admin.ServerlessInstanceDescription)) *ClustersApi_UpgradeSharedClusterToServerless_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.ServerlessInstanceDescription)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerless_Call) Return(_a0 admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerless_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerless_Call) RunAndReturn(run func(context.Context, string, *admin.ServerlessInstanceDescription) admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerless_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedClusterToServerlessExecute provides a mock function with given fields: r -func (_m *ClustersApi) UpgradeSharedClusterToServerlessExecute(r admin.UpgradeSharedClusterToServerlessApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedClusterToServerlessExecute") - } - - var r0 *admin.ServerlessInstanceDescription - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpgradeSharedClusterToServerlessApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpgradeSharedClusterToServerlessApiRequest) *admin.ServerlessInstanceDescription); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.ServerlessInstanceDescription) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpgradeSharedClusterToServerlessApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpgradeSharedClusterToServerlessApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ClustersApi_UpgradeSharedClusterToServerlessExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedClusterToServerlessExecute' -type ClustersApi_UpgradeSharedClusterToServerlessExecute_Call struct { - *mock.Call -} - -// UpgradeSharedClusterToServerlessExecute is a helper method to define mock.On call -// - r admin.UpgradeSharedClusterToServerlessApiRequest -func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerlessExecute(r interface{}) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call { - return &ClustersApi_UpgradeSharedClusterToServerlessExecute_Call{Call: _e.mock.On("UpgradeSharedClusterToServerlessExecute", r)} -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call) Run(run func(r admin.UpgradeSharedClusterToServerlessApiRequest)) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpgradeSharedClusterToServerlessApiRequest)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call) Return(_a0 *admin.ServerlessInstanceDescription, _a1 *http.Response, _a2 error) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call) RunAndReturn(run func(admin.UpgradeSharedClusterToServerlessApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ClustersApi_UpgradeSharedClusterToServerlessExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedClusterToServerlessWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) UpgradeSharedClusterToServerlessWithParams(ctx context.Context, args *admin.UpgradeSharedClusterToServerlessApiParams) admin.UpgradeSharedClusterToServerlessApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedClusterToServerlessWithParams") - } - - var r0 admin.UpgradeSharedClusterToServerlessApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpgradeSharedClusterToServerlessApiParams) admin.UpgradeSharedClusterToServerlessApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpgradeSharedClusterToServerlessApiRequest) - } - - return r0 -} - -// ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedClusterToServerlessWithParams' -type ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call struct { - *mock.Call -} - -// UpgradeSharedClusterToServerlessWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpgradeSharedClusterToServerlessApiParams -func (_e *ClustersApi_Expecter) UpgradeSharedClusterToServerlessWithParams(ctx interface{}, args interface{}) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call { - return &ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call{Call: _e.mock.On("UpgradeSharedClusterToServerlessWithParams", ctx, args)} -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call) Run(run func(ctx context.Context, args *admin.UpgradeSharedClusterToServerlessApiParams)) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpgradeSharedClusterToServerlessApiParams)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call) Return(_a0 admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpgradeSharedClusterToServerlessApiParams) admin.UpgradeSharedClusterToServerlessApiRequest) *ClustersApi_UpgradeSharedClusterToServerlessWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpgradeSharedClusterWithParams provides a mock function with given fields: ctx, args -func (_m *ClustersApi) UpgradeSharedClusterWithParams(ctx context.Context, args *admin.UpgradeSharedClusterApiParams) admin.UpgradeSharedClusterApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpgradeSharedClusterWithParams") - } - - var r0 admin.UpgradeSharedClusterApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpgradeSharedClusterApiParams) admin.UpgradeSharedClusterApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpgradeSharedClusterApiRequest) - } - - return r0 -} - -// ClustersApi_UpgradeSharedClusterWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpgradeSharedClusterWithParams' -type ClustersApi_UpgradeSharedClusterWithParams_Call struct { - *mock.Call -} - -// UpgradeSharedClusterWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpgradeSharedClusterApiParams -func (_e *ClustersApi_Expecter) UpgradeSharedClusterWithParams(ctx interface{}, args interface{}) *ClustersApi_UpgradeSharedClusterWithParams_Call { - return &ClustersApi_UpgradeSharedClusterWithParams_Call{Call: _e.mock.On("UpgradeSharedClusterWithParams", ctx, args)} -} - -func (_c *ClustersApi_UpgradeSharedClusterWithParams_Call) Run(run func(ctx context.Context, args *admin.UpgradeSharedClusterApiParams)) *ClustersApi_UpgradeSharedClusterWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpgradeSharedClusterApiParams)) - }) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterWithParams_Call) Return(_a0 admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedClusterWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ClustersApi_UpgradeSharedClusterWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpgradeSharedClusterApiParams) admin.UpgradeSharedClusterApiRequest) *ClustersApi_UpgradeSharedClusterWithParams_Call { - _c.Call.Return(run) - return _c -} - -// NewClustersApi creates a new instance of ClustersApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewClustersApi(t interface { - mock.TestingT - Cleanup(func()) -}) *ClustersApi { - mock := &ClustersApi{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/testutil/mocksvc/encryption_at_rest_using_customer_key_management_api.go b/internal/testutil/mocksvc/encryption_at_rest_using_customer_key_management_api.go deleted file mode 100644 index e9e2bc92d4..0000000000 --- a/internal/testutil/mocksvc/encryption_at_rest_using_customer_key_management_api.go +++ /dev/null @@ -1,363 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocksvc - -import ( - context "context" - - admin "go.mongodb.org/atlas-sdk/v20231115008/admin" - - http "net/http" - - mock "github.com/stretchr/testify/mock" -) - -// EncryptionAtRestUsingCustomerKeyManagementApi is an autogenerated mock type for the EncryptionAtRestUsingCustomerKeyManagementApi type -type EncryptionAtRestUsingCustomerKeyManagementApi struct { - mock.Mock -} - -type EncryptionAtRestUsingCustomerKeyManagementApi_Expecter struct { - mock *mock.Mock -} - -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) EXPECT() *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter { - return &EncryptionAtRestUsingCustomerKeyManagementApi_Expecter{mock: &_m.Mock} -} - -// GetEncryptionAtRest provides a mock function with given fields: ctx, groupId -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) GetEncryptionAtRest(ctx context.Context, groupId string) admin.GetEncryptionAtRestApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for GetEncryptionAtRest") - } - - var r0 admin.GetEncryptionAtRestApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetEncryptionAtRestApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.GetEncryptionAtRestApiRequest) - } - - return r0 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEncryptionAtRest' -type EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call struct { - *mock.Call -} - -// GetEncryptionAtRest is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) GetEncryptionAtRest(ctx interface{}, groupId interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call{Call: _e.mock.On("GetEncryptionAtRest", ctx, groupId)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call) Run(run func(ctx context.Context, groupId string)) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call) Return(_a0 admin.GetEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call) RunAndReturn(run func(context.Context, string) admin.GetEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRest_Call { - _c.Call.Return(run) - return _c -} - -// GetEncryptionAtRestExecute provides a mock function with given fields: r -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) GetEncryptionAtRestExecute(r admin.GetEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetEncryptionAtRestExecute") - } - - var r0 *admin.EncryptionAtRest - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetEncryptionAtRestApiRequest) *admin.EncryptionAtRest); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.EncryptionAtRest) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetEncryptionAtRestApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetEncryptionAtRestApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEncryptionAtRestExecute' -type EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call struct { - *mock.Call -} - -// GetEncryptionAtRestExecute is a helper method to define mock.On call -// - r admin.GetEncryptionAtRestApiRequest -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) GetEncryptionAtRestExecute(r interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call{Call: _e.mock.On("GetEncryptionAtRestExecute", r)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call) Run(run func(r admin.GetEncryptionAtRestApiRequest)) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetEncryptionAtRestApiRequest)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call) Return(_a0 *admin.EncryptionAtRest, _a1 *http.Response, _a2 error) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call) RunAndReturn(run func(admin.GetEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error)) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetEncryptionAtRestWithParams provides a mock function with given fields: ctx, args -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) GetEncryptionAtRestWithParams(ctx context.Context, args *admin.GetEncryptionAtRestApiParams) admin.GetEncryptionAtRestApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetEncryptionAtRestWithParams") - } - - var r0 admin.GetEncryptionAtRestApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetEncryptionAtRestApiParams) admin.GetEncryptionAtRestApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetEncryptionAtRestApiRequest) - } - - return r0 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEncryptionAtRestWithParams' -type EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call struct { - *mock.Call -} - -// GetEncryptionAtRestWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetEncryptionAtRestApiParams -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) GetEncryptionAtRestWithParams(ctx interface{}, args interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call{Call: _e.mock.On("GetEncryptionAtRestWithParams", ctx, args)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call) Run(run func(ctx context.Context, args *admin.GetEncryptionAtRestApiParams)) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetEncryptionAtRestApiParams)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call) Return(_a0 admin.GetEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetEncryptionAtRestApiParams) admin.GetEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_GetEncryptionAtRestWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateEncryptionAtRest provides a mock function with given fields: ctx, groupId, encryptionAtRest -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) UpdateEncryptionAtRest(ctx context.Context, groupId string, encryptionAtRest *admin.EncryptionAtRest) admin.UpdateEncryptionAtRestApiRequest { - ret := _m.Called(ctx, groupId, encryptionAtRest) - - if len(ret) == 0 { - panic("no return value specified for UpdateEncryptionAtRest") - } - - var r0 admin.UpdateEncryptionAtRestApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.EncryptionAtRest) admin.UpdateEncryptionAtRestApiRequest); ok { - r0 = rf(ctx, groupId, encryptionAtRest) - } else { - r0 = ret.Get(0).(admin.UpdateEncryptionAtRestApiRequest) - } - - return r0 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEncryptionAtRest' -type EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call struct { - *mock.Call -} - -// UpdateEncryptionAtRest is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - encryptionAtRest *admin.EncryptionAtRest -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) UpdateEncryptionAtRest(ctx interface{}, groupId interface{}, encryptionAtRest interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call{Call: _e.mock.On("UpdateEncryptionAtRest", ctx, groupId, encryptionAtRest)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call) Run(run func(ctx context.Context, groupId string, encryptionAtRest *admin.EncryptionAtRest)) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.EncryptionAtRest)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call) Return(_a0 admin.UpdateEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call) RunAndReturn(run func(context.Context, string, *admin.EncryptionAtRest) admin.UpdateEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRest_Call { - _c.Call.Return(run) - return _c -} - -// UpdateEncryptionAtRestExecute provides a mock function with given fields: r -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) UpdateEncryptionAtRestExecute(r admin.UpdateEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateEncryptionAtRestExecute") - } - - var r0 *admin.EncryptionAtRest - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateEncryptionAtRestApiRequest) *admin.EncryptionAtRest); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.EncryptionAtRest) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateEncryptionAtRestApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateEncryptionAtRestApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEncryptionAtRestExecute' -type EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call struct { - *mock.Call -} - -// UpdateEncryptionAtRestExecute is a helper method to define mock.On call -// - r admin.UpdateEncryptionAtRestApiRequest -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) UpdateEncryptionAtRestExecute(r interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call{Call: _e.mock.On("UpdateEncryptionAtRestExecute", r)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call) Run(run func(r admin.UpdateEncryptionAtRestApiRequest)) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateEncryptionAtRestApiRequest)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call) Return(_a0 *admin.EncryptionAtRest, _a1 *http.Response, _a2 error) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call) RunAndReturn(run func(admin.UpdateEncryptionAtRestApiRequest) (*admin.EncryptionAtRest, *http.Response, error)) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateEncryptionAtRestWithParams provides a mock function with given fields: ctx, args -func (_m *EncryptionAtRestUsingCustomerKeyManagementApi) UpdateEncryptionAtRestWithParams(ctx context.Context, args *admin.UpdateEncryptionAtRestApiParams) admin.UpdateEncryptionAtRestApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateEncryptionAtRestWithParams") - } - - var r0 admin.UpdateEncryptionAtRestApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateEncryptionAtRestApiParams) admin.UpdateEncryptionAtRestApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateEncryptionAtRestApiRequest) - } - - return r0 -} - -// EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEncryptionAtRestWithParams' -type EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call struct { - *mock.Call -} - -// UpdateEncryptionAtRestWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateEncryptionAtRestApiParams -func (_e *EncryptionAtRestUsingCustomerKeyManagementApi_Expecter) UpdateEncryptionAtRestWithParams(ctx interface{}, args interface{}) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call { - return &EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call{Call: _e.mock.On("UpdateEncryptionAtRestWithParams", ctx, args)} -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateEncryptionAtRestApiParams)) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateEncryptionAtRestApiParams)) - }) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call) Return(_a0 admin.UpdateEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateEncryptionAtRestApiParams) admin.UpdateEncryptionAtRestApiRequest) *EncryptionAtRestUsingCustomerKeyManagementApi_UpdateEncryptionAtRestWithParams_Call { - _c.Call.Return(run) - return _c -} - -// NewEncryptionAtRestUsingCustomerKeyManagementApi creates a new instance of EncryptionAtRestUsingCustomerKeyManagementApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewEncryptionAtRestUsingCustomerKeyManagementApi(t interface { - mock.TestingT - Cleanup(func()) -}) *EncryptionAtRestUsingCustomerKeyManagementApi { - mock := &EncryptionAtRestUsingCustomerKeyManagementApi{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/testutil/mocksvc/projects_api.go b/internal/testutil/mocksvc/projects_api.go deleted file mode 100644 index 8cb8156582..0000000000 --- a/internal/testutil/mocksvc/projects_api.go +++ /dev/null @@ -1,3749 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocksvc - -import ( - context "context" - - admin "go.mongodb.org/atlas-sdk/v20231115008/admin" - - http "net/http" - - mock "github.com/stretchr/testify/mock" -) - -// ProjectsApi is an autogenerated mock type for the ProjectsApi type -type ProjectsApi struct { - mock.Mock -} - -type ProjectsApi_Expecter struct { - mock *mock.Mock -} - -func (_m *ProjectsApi) EXPECT() *ProjectsApi_Expecter { - return &ProjectsApi_Expecter{mock: &_m.Mock} -} - -// AddUserToProject provides a mock function with given fields: ctx, groupId, groupInvitationRequest -func (_m *ProjectsApi) AddUserToProject(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest) admin.AddUserToProjectApiRequest { - ret := _m.Called(ctx, groupId, groupInvitationRequest) - - if len(ret) == 0 { - panic("no return value specified for AddUserToProject") - } - - var r0 admin.AddUserToProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupInvitationRequest) admin.AddUserToProjectApiRequest); ok { - r0 = rf(ctx, groupId, groupInvitationRequest) - } else { - r0 = ret.Get(0).(admin.AddUserToProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_AddUserToProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToProject' -type ProjectsApi_AddUserToProject_Call struct { - *mock.Call -} - -// AddUserToProject is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - groupInvitationRequest *admin.GroupInvitationRequest -func (_e *ProjectsApi_Expecter) AddUserToProject(ctx interface{}, groupId interface{}, groupInvitationRequest interface{}) *ProjectsApi_AddUserToProject_Call { - return &ProjectsApi_AddUserToProject_Call{Call: _e.mock.On("AddUserToProject", ctx, groupId, groupInvitationRequest)} -} - -func (_c *ProjectsApi_AddUserToProject_Call) Run(run func(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest)) *ProjectsApi_AddUserToProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupInvitationRequest)) - }) - return _c -} - -func (_c *ProjectsApi_AddUserToProject_Call) Return(_a0 admin.AddUserToProjectApiRequest) *ProjectsApi_AddUserToProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_AddUserToProject_Call) RunAndReturn(run func(context.Context, string, *admin.GroupInvitationRequest) admin.AddUserToProjectApiRequest) *ProjectsApi_AddUserToProject_Call { - _c.Call.Return(run) - return _c -} - -// AddUserToProjectExecute provides a mock function with given fields: r -func (_m *ProjectsApi) AddUserToProjectExecute(r admin.AddUserToProjectApiRequest) (*admin.OrganizationInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for AddUserToProjectExecute") - } - - var r0 *admin.OrganizationInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.AddUserToProjectApiRequest) (*admin.OrganizationInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.AddUserToProjectApiRequest) *admin.OrganizationInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.OrganizationInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.AddUserToProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.AddUserToProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_AddUserToProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToProjectExecute' -type ProjectsApi_AddUserToProjectExecute_Call struct { - *mock.Call -} - -// AddUserToProjectExecute is a helper method to define mock.On call -// - r admin.AddUserToProjectApiRequest -func (_e *ProjectsApi_Expecter) AddUserToProjectExecute(r interface{}) *ProjectsApi_AddUserToProjectExecute_Call { - return &ProjectsApi_AddUserToProjectExecute_Call{Call: _e.mock.On("AddUserToProjectExecute", r)} -} - -func (_c *ProjectsApi_AddUserToProjectExecute_Call) Run(run func(r admin.AddUserToProjectApiRequest)) *ProjectsApi_AddUserToProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.AddUserToProjectApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_AddUserToProjectExecute_Call) Return(_a0 *admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_AddUserToProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_AddUserToProjectExecute_Call) RunAndReturn(run func(admin.AddUserToProjectApiRequest) (*admin.OrganizationInvitation, *http.Response, error)) *ProjectsApi_AddUserToProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// AddUserToProjectWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) AddUserToProjectWithParams(ctx context.Context, args *admin.AddUserToProjectApiParams) admin.AddUserToProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for AddUserToProjectWithParams") - } - - var r0 admin.AddUserToProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.AddUserToProjectApiParams) admin.AddUserToProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.AddUserToProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_AddUserToProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToProjectWithParams' -type ProjectsApi_AddUserToProjectWithParams_Call struct { - *mock.Call -} - -// AddUserToProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.AddUserToProjectApiParams -func (_e *ProjectsApi_Expecter) AddUserToProjectWithParams(ctx interface{}, args interface{}) *ProjectsApi_AddUserToProjectWithParams_Call { - return &ProjectsApi_AddUserToProjectWithParams_Call{Call: _e.mock.On("AddUserToProjectWithParams", ctx, args)} -} - -func (_c *ProjectsApi_AddUserToProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.AddUserToProjectApiParams)) *ProjectsApi_AddUserToProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.AddUserToProjectApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_AddUserToProjectWithParams_Call) Return(_a0 admin.AddUserToProjectApiRequest) *ProjectsApi_AddUserToProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_AddUserToProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddUserToProjectApiParams) admin.AddUserToProjectApiRequest) *ProjectsApi_AddUserToProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// CreateProject provides a mock function with given fields: ctx, group -func (_m *ProjectsApi) CreateProject(ctx context.Context, group *admin.Group) admin.CreateProjectApiRequest { - ret := _m.Called(ctx, group) - - if len(ret) == 0 { - panic("no return value specified for CreateProject") - } - - var r0 admin.CreateProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.Group) admin.CreateProjectApiRequest); ok { - r0 = rf(ctx, group) - } else { - r0 = ret.Get(0).(admin.CreateProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_CreateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProject' -type ProjectsApi_CreateProject_Call struct { - *mock.Call -} - -// CreateProject is a helper method to define mock.On call -// - ctx context.Context -// - group *admin.Group -func (_e *ProjectsApi_Expecter) CreateProject(ctx interface{}, group interface{}) *ProjectsApi_CreateProject_Call { - return &ProjectsApi_CreateProject_Call{Call: _e.mock.On("CreateProject", ctx, group)} -} - -func (_c *ProjectsApi_CreateProject_Call) Run(run func(ctx context.Context, group *admin.Group)) *ProjectsApi_CreateProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.Group)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProject_Call) Return(_a0 admin.CreateProjectApiRequest) *ProjectsApi_CreateProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_CreateProject_Call) RunAndReturn(run func(context.Context, *admin.Group) admin.CreateProjectApiRequest) *ProjectsApi_CreateProject_Call { - _c.Call.Return(run) - return _c -} - -// CreateProjectExecute provides a mock function with given fields: r -func (_m *ProjectsApi) CreateProjectExecute(r admin.CreateProjectApiRequest) (*admin.Group, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateProjectExecute") - } - - var r0 *admin.Group - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateProjectApiRequest) (*admin.Group, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateProjectApiRequest) *admin.Group); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.Group) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_CreateProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectExecute' -type ProjectsApi_CreateProjectExecute_Call struct { - *mock.Call -} - -// CreateProjectExecute is a helper method to define mock.On call -// - r admin.CreateProjectApiRequest -func (_e *ProjectsApi_Expecter) CreateProjectExecute(r interface{}) *ProjectsApi_CreateProjectExecute_Call { - return &ProjectsApi_CreateProjectExecute_Call{Call: _e.mock.On("CreateProjectExecute", r)} -} - -func (_c *ProjectsApi_CreateProjectExecute_Call) Run(run func(r admin.CreateProjectApiRequest)) *ProjectsApi_CreateProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateProjectApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProjectExecute_Call) Return(_a0 *admin.Group, _a1 *http.Response, _a2 error) *ProjectsApi_CreateProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_CreateProjectExecute_Call) RunAndReturn(run func(admin.CreateProjectApiRequest) (*admin.Group, *http.Response, error)) *ProjectsApi_CreateProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateProjectInvitation provides a mock function with given fields: ctx, groupId, groupInvitationRequest -func (_m *ProjectsApi) CreateProjectInvitation(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest) admin.CreateProjectInvitationApiRequest { - ret := _m.Called(ctx, groupId, groupInvitationRequest) - - if len(ret) == 0 { - panic("no return value specified for CreateProjectInvitation") - } - - var r0 admin.CreateProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupInvitationRequest) admin.CreateProjectInvitationApiRequest); ok { - r0 = rf(ctx, groupId, groupInvitationRequest) - } else { - r0 = ret.Get(0).(admin.CreateProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_CreateProjectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectInvitation' -type ProjectsApi_CreateProjectInvitation_Call struct { - *mock.Call -} - -// CreateProjectInvitation is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - groupInvitationRequest *admin.GroupInvitationRequest -func (_e *ProjectsApi_Expecter) CreateProjectInvitation(ctx interface{}, groupId interface{}, groupInvitationRequest interface{}) *ProjectsApi_CreateProjectInvitation_Call { - return &ProjectsApi_CreateProjectInvitation_Call{Call: _e.mock.On("CreateProjectInvitation", ctx, groupId, groupInvitationRequest)} -} - -func (_c *ProjectsApi_CreateProjectInvitation_Call) Run(run func(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest)) *ProjectsApi_CreateProjectInvitation_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupInvitationRequest)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitation_Call) Return(_a0 admin.CreateProjectInvitationApiRequest) *ProjectsApi_CreateProjectInvitation_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitation_Call) RunAndReturn(run func(context.Context, string, *admin.GroupInvitationRequest) admin.CreateProjectInvitationApiRequest) *ProjectsApi_CreateProjectInvitation_Call { - _c.Call.Return(run) - return _c -} - -// CreateProjectInvitationExecute provides a mock function with given fields: r -func (_m *ProjectsApi) CreateProjectInvitationExecute(r admin.CreateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateProjectInvitationExecute") - } - - var r0 *admin.GroupInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateProjectInvitationApiRequest) *admin.GroupInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateProjectInvitationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateProjectInvitationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_CreateProjectInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectInvitationExecute' -type ProjectsApi_CreateProjectInvitationExecute_Call struct { - *mock.Call -} - -// CreateProjectInvitationExecute is a helper method to define mock.On call -// - r admin.CreateProjectInvitationApiRequest -func (_e *ProjectsApi_Expecter) CreateProjectInvitationExecute(r interface{}) *ProjectsApi_CreateProjectInvitationExecute_Call { - return &ProjectsApi_CreateProjectInvitationExecute_Call{Call: _e.mock.On("CreateProjectInvitationExecute", r)} -} - -func (_c *ProjectsApi_CreateProjectInvitationExecute_Call) Run(run func(r admin.CreateProjectInvitationApiRequest)) *ProjectsApi_CreateProjectInvitationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateProjectInvitationApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitationExecute_Call) Return(_a0 *admin.GroupInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_CreateProjectInvitationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitationExecute_Call) RunAndReturn(run func(admin.CreateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)) *ProjectsApi_CreateProjectInvitationExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateProjectInvitationWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) CreateProjectInvitationWithParams(ctx context.Context, args *admin.CreateProjectInvitationApiParams) admin.CreateProjectInvitationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateProjectInvitationWithParams") - } - - var r0 admin.CreateProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateProjectInvitationApiParams) admin.CreateProjectInvitationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_CreateProjectInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectInvitationWithParams' -type ProjectsApi_CreateProjectInvitationWithParams_Call struct { - *mock.Call -} - -// CreateProjectInvitationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateProjectInvitationApiParams -func (_e *ProjectsApi_Expecter) CreateProjectInvitationWithParams(ctx interface{}, args interface{}) *ProjectsApi_CreateProjectInvitationWithParams_Call { - return &ProjectsApi_CreateProjectInvitationWithParams_Call{Call: _e.mock.On("CreateProjectInvitationWithParams", ctx, args)} -} - -func (_c *ProjectsApi_CreateProjectInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateProjectInvitationApiParams)) *ProjectsApi_CreateProjectInvitationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateProjectInvitationApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitationWithParams_Call) Return(_a0 admin.CreateProjectInvitationApiRequest) *ProjectsApi_CreateProjectInvitationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_CreateProjectInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateProjectInvitationApiParams) admin.CreateProjectInvitationApiRequest) *ProjectsApi_CreateProjectInvitationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// CreateProjectWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) CreateProjectWithParams(ctx context.Context, args *admin.CreateProjectApiParams) admin.CreateProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateProjectWithParams") - } - - var r0 admin.CreateProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateProjectApiParams) admin.CreateProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_CreateProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectWithParams' -type ProjectsApi_CreateProjectWithParams_Call struct { - *mock.Call -} - -// CreateProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateProjectApiParams -func (_e *ProjectsApi_Expecter) CreateProjectWithParams(ctx interface{}, args interface{}) *ProjectsApi_CreateProjectWithParams_Call { - return &ProjectsApi_CreateProjectWithParams_Call{Call: _e.mock.On("CreateProjectWithParams", ctx, args)} -} - -func (_c *ProjectsApi_CreateProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateProjectApiParams)) *ProjectsApi_CreateProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateProjectApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_CreateProjectWithParams_Call) Return(_a0 admin.CreateProjectApiRequest) *ProjectsApi_CreateProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_CreateProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateProjectApiParams) admin.CreateProjectApiRequest) *ProjectsApi_CreateProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProject provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) DeleteProject(ctx context.Context, groupId string) admin.DeleteProjectApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for DeleteProject") - } - - var r0 admin.DeleteProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteProjectApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.DeleteProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProject' -type ProjectsApi_DeleteProject_Call struct { - *mock.Call -} - -// DeleteProject is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) DeleteProject(ctx interface{}, groupId interface{}) *ProjectsApi_DeleteProject_Call { - return &ProjectsApi_DeleteProject_Call{Call: _e.mock.On("DeleteProject", ctx, groupId)} -} - -func (_c *ProjectsApi_DeleteProject_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_DeleteProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProject_Call) Return(_a0 admin.DeleteProjectApiRequest) *ProjectsApi_DeleteProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProject_Call) RunAndReturn(run func(context.Context, string) admin.DeleteProjectApiRequest) *ProjectsApi_DeleteProject_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectExecute provides a mock function with given fields: r -func (_m *ProjectsApi) DeleteProjectExecute(r admin.DeleteProjectApiRequest) (map[string]interface{}, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectExecute") - } - - var r0 map[string]interface{} - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.DeleteProjectApiRequest) (map[string]interface{}, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteProjectApiRequest) map[string]interface{}); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(map[string]interface{}) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.DeleteProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_DeleteProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectExecute' -type ProjectsApi_DeleteProjectExecute_Call struct { - *mock.Call -} - -// DeleteProjectExecute is a helper method to define mock.On call -// - r admin.DeleteProjectApiRequest -func (_e *ProjectsApi_Expecter) DeleteProjectExecute(r interface{}) *ProjectsApi_DeleteProjectExecute_Call { - return &ProjectsApi_DeleteProjectExecute_Call{Call: _e.mock.On("DeleteProjectExecute", r)} -} - -func (_c *ProjectsApi_DeleteProjectExecute_Call) Run(run func(r admin.DeleteProjectApiRequest)) *ProjectsApi_DeleteProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteProjectApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProjectsApi_DeleteProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_DeleteProjectExecute_Call) RunAndReturn(run func(admin.DeleteProjectApiRequest) (map[string]interface{}, *http.Response, error)) *ProjectsApi_DeleteProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectInvitation provides a mock function with given fields: ctx, groupId, invitationId -func (_m *ProjectsApi) DeleteProjectInvitation(ctx context.Context, groupId string, invitationId string) admin.DeleteProjectInvitationApiRequest { - ret := _m.Called(ctx, groupId, invitationId) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectInvitation") - } - - var r0 admin.DeleteProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteProjectInvitationApiRequest); ok { - r0 = rf(ctx, groupId, invitationId) - } else { - r0 = ret.Get(0).(admin.DeleteProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProjectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectInvitation' -type ProjectsApi_DeleteProjectInvitation_Call struct { - *mock.Call -} - -// DeleteProjectInvitation is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - invitationId string -func (_e *ProjectsApi_Expecter) DeleteProjectInvitation(ctx interface{}, groupId interface{}, invitationId interface{}) *ProjectsApi_DeleteProjectInvitation_Call { - return &ProjectsApi_DeleteProjectInvitation_Call{Call: _e.mock.On("DeleteProjectInvitation", ctx, groupId, invitationId)} -} - -func (_c *ProjectsApi_DeleteProjectInvitation_Call) Run(run func(ctx context.Context, groupId string, invitationId string)) *ProjectsApi_DeleteProjectInvitation_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitation_Call) Return(_a0 admin.DeleteProjectInvitationApiRequest) *ProjectsApi_DeleteProjectInvitation_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitation_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteProjectInvitationApiRequest) *ProjectsApi_DeleteProjectInvitation_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectInvitationExecute provides a mock function with given fields: r -func (_m *ProjectsApi) DeleteProjectInvitationExecute(r admin.DeleteProjectInvitationApiRequest) (map[string]interface{}, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectInvitationExecute") - } - - var r0 map[string]interface{} - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.DeleteProjectInvitationApiRequest) (map[string]interface{}, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteProjectInvitationApiRequest) map[string]interface{}); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(map[string]interface{}) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteProjectInvitationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.DeleteProjectInvitationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_DeleteProjectInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectInvitationExecute' -type ProjectsApi_DeleteProjectInvitationExecute_Call struct { - *mock.Call -} - -// DeleteProjectInvitationExecute is a helper method to define mock.On call -// - r admin.DeleteProjectInvitationApiRequest -func (_e *ProjectsApi_Expecter) DeleteProjectInvitationExecute(r interface{}) *ProjectsApi_DeleteProjectInvitationExecute_Call { - return &ProjectsApi_DeleteProjectInvitationExecute_Call{Call: _e.mock.On("DeleteProjectInvitationExecute", r)} -} - -func (_c *ProjectsApi_DeleteProjectInvitationExecute_Call) Run(run func(r admin.DeleteProjectInvitationApiRequest)) *ProjectsApi_DeleteProjectInvitationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteProjectInvitationApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitationExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProjectsApi_DeleteProjectInvitationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitationExecute_Call) RunAndReturn(run func(admin.DeleteProjectInvitationApiRequest) (map[string]interface{}, *http.Response, error)) *ProjectsApi_DeleteProjectInvitationExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectInvitationWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) DeleteProjectInvitationWithParams(ctx context.Context, args *admin.DeleteProjectInvitationApiParams) admin.DeleteProjectInvitationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectInvitationWithParams") - } - - var r0 admin.DeleteProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteProjectInvitationApiParams) admin.DeleteProjectInvitationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProjectInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectInvitationWithParams' -type ProjectsApi_DeleteProjectInvitationWithParams_Call struct { - *mock.Call -} - -// DeleteProjectInvitationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteProjectInvitationApiParams -func (_e *ProjectsApi_Expecter) DeleteProjectInvitationWithParams(ctx interface{}, args interface{}) *ProjectsApi_DeleteProjectInvitationWithParams_Call { - return &ProjectsApi_DeleteProjectInvitationWithParams_Call{Call: _e.mock.On("DeleteProjectInvitationWithParams", ctx, args)} -} - -func (_c *ProjectsApi_DeleteProjectInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteProjectInvitationApiParams)) *ProjectsApi_DeleteProjectInvitationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteProjectInvitationApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitationWithParams_Call) Return(_a0 admin.DeleteProjectInvitationApiRequest) *ProjectsApi_DeleteProjectInvitationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProjectInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteProjectInvitationApiParams) admin.DeleteProjectInvitationApiRequest) *ProjectsApi_DeleteProjectInvitationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectLimit provides a mock function with given fields: ctx, limitName, groupId -func (_m *ProjectsApi) DeleteProjectLimit(ctx context.Context, limitName string, groupId string) admin.DeleteProjectLimitApiRequest { - ret := _m.Called(ctx, limitName, groupId) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectLimit") - } - - var r0 admin.DeleteProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteProjectLimitApiRequest); ok { - r0 = rf(ctx, limitName, groupId) - } else { - r0 = ret.Get(0).(admin.DeleteProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProjectLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectLimit' -type ProjectsApi_DeleteProjectLimit_Call struct { - *mock.Call -} - -// DeleteProjectLimit is a helper method to define mock.On call -// - ctx context.Context -// - limitName string -// - groupId string -func (_e *ProjectsApi_Expecter) DeleteProjectLimit(ctx interface{}, limitName interface{}, groupId interface{}) *ProjectsApi_DeleteProjectLimit_Call { - return &ProjectsApi_DeleteProjectLimit_Call{Call: _e.mock.On("DeleteProjectLimit", ctx, limitName, groupId)} -} - -func (_c *ProjectsApi_DeleteProjectLimit_Call) Run(run func(ctx context.Context, limitName string, groupId string)) *ProjectsApi_DeleteProjectLimit_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimit_Call) Return(_a0 admin.DeleteProjectLimitApiRequest) *ProjectsApi_DeleteProjectLimit_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimit_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteProjectLimitApiRequest) *ProjectsApi_DeleteProjectLimit_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectLimitExecute provides a mock function with given fields: r -func (_m *ProjectsApi) DeleteProjectLimitExecute(r admin.DeleteProjectLimitApiRequest) (map[string]interface{}, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectLimitExecute") - } - - var r0 map[string]interface{} - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.DeleteProjectLimitApiRequest) (map[string]interface{}, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteProjectLimitApiRequest) map[string]interface{}); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(map[string]interface{}) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteProjectLimitApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.DeleteProjectLimitApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_DeleteProjectLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectLimitExecute' -type ProjectsApi_DeleteProjectLimitExecute_Call struct { - *mock.Call -} - -// DeleteProjectLimitExecute is a helper method to define mock.On call -// - r admin.DeleteProjectLimitApiRequest -func (_e *ProjectsApi_Expecter) DeleteProjectLimitExecute(r interface{}) *ProjectsApi_DeleteProjectLimitExecute_Call { - return &ProjectsApi_DeleteProjectLimitExecute_Call{Call: _e.mock.On("DeleteProjectLimitExecute", r)} -} - -func (_c *ProjectsApi_DeleteProjectLimitExecute_Call) Run(run func(r admin.DeleteProjectLimitApiRequest)) *ProjectsApi_DeleteProjectLimitExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteProjectLimitApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimitExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProjectsApi_DeleteProjectLimitExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimitExecute_Call) RunAndReturn(run func(admin.DeleteProjectLimitApiRequest) (map[string]interface{}, *http.Response, error)) *ProjectsApi_DeleteProjectLimitExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectLimitWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) DeleteProjectLimitWithParams(ctx context.Context, args *admin.DeleteProjectLimitApiParams) admin.DeleteProjectLimitApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectLimitWithParams") - } - - var r0 admin.DeleteProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteProjectLimitApiParams) admin.DeleteProjectLimitApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProjectLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectLimitWithParams' -type ProjectsApi_DeleteProjectLimitWithParams_Call struct { - *mock.Call -} - -// DeleteProjectLimitWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteProjectLimitApiParams -func (_e *ProjectsApi_Expecter) DeleteProjectLimitWithParams(ctx interface{}, args interface{}) *ProjectsApi_DeleteProjectLimitWithParams_Call { - return &ProjectsApi_DeleteProjectLimitWithParams_Call{Call: _e.mock.On("DeleteProjectLimitWithParams", ctx, args)} -} - -func (_c *ProjectsApi_DeleteProjectLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteProjectLimitApiParams)) *ProjectsApi_DeleteProjectLimitWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteProjectLimitApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimitWithParams_Call) Return(_a0 admin.DeleteProjectLimitApiRequest) *ProjectsApi_DeleteProjectLimitWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProjectLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteProjectLimitApiParams) admin.DeleteProjectLimitApiRequest) *ProjectsApi_DeleteProjectLimitWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteProjectWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) DeleteProjectWithParams(ctx context.Context, args *admin.DeleteProjectApiParams) admin.DeleteProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteProjectWithParams") - } - - var r0 admin.DeleteProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteProjectApiParams) admin.DeleteProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_DeleteProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectWithParams' -type ProjectsApi_DeleteProjectWithParams_Call struct { - *mock.Call -} - -// DeleteProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteProjectApiParams -func (_e *ProjectsApi_Expecter) DeleteProjectWithParams(ctx interface{}, args interface{}) *ProjectsApi_DeleteProjectWithParams_Call { - return &ProjectsApi_DeleteProjectWithParams_Call{Call: _e.mock.On("DeleteProjectWithParams", ctx, args)} -} - -func (_c *ProjectsApi_DeleteProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteProjectApiParams)) *ProjectsApi_DeleteProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteProjectApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_DeleteProjectWithParams_Call) Return(_a0 admin.DeleteProjectApiRequest) *ProjectsApi_DeleteProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_DeleteProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteProjectApiParams) admin.DeleteProjectApiRequest) *ProjectsApi_DeleteProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetProject provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) GetProject(ctx context.Context, groupId string) admin.GetProjectApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for GetProject") - } - - var r0 admin.GetProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetProjectApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.GetProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProject' -type ProjectsApi_GetProject_Call struct { - *mock.Call -} - -// GetProject is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) GetProject(ctx interface{}, groupId interface{}) *ProjectsApi_GetProject_Call { - return &ProjectsApi_GetProject_Call{Call: _e.mock.On("GetProject", ctx, groupId)} -} - -func (_c *ProjectsApi_GetProject_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_GetProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_GetProject_Call) Return(_a0 admin.GetProjectApiRequest) *ProjectsApi_GetProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProject_Call) RunAndReturn(run func(context.Context, string) admin.GetProjectApiRequest) *ProjectsApi_GetProject_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectByName provides a mock function with given fields: ctx, groupName -func (_m *ProjectsApi) GetProjectByName(ctx context.Context, groupName string) admin.GetProjectByNameApiRequest { - ret := _m.Called(ctx, groupName) - - if len(ret) == 0 { - panic("no return value specified for GetProjectByName") - } - - var r0 admin.GetProjectByNameApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetProjectByNameApiRequest); ok { - r0 = rf(ctx, groupName) - } else { - r0 = ret.Get(0).(admin.GetProjectByNameApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectByName' -type ProjectsApi_GetProjectByName_Call struct { - *mock.Call -} - -// GetProjectByName is a helper method to define mock.On call -// - ctx context.Context -// - groupName string -func (_e *ProjectsApi_Expecter) GetProjectByName(ctx interface{}, groupName interface{}) *ProjectsApi_GetProjectByName_Call { - return &ProjectsApi_GetProjectByName_Call{Call: _e.mock.On("GetProjectByName", ctx, groupName)} -} - -func (_c *ProjectsApi_GetProjectByName_Call) Run(run func(ctx context.Context, groupName string)) *ProjectsApi_GetProjectByName_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectByName_Call) Return(_a0 admin.GetProjectByNameApiRequest) *ProjectsApi_GetProjectByName_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectByName_Call) RunAndReturn(run func(context.Context, string) admin.GetProjectByNameApiRequest) *ProjectsApi_GetProjectByName_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectByNameExecute provides a mock function with given fields: r -func (_m *ProjectsApi) GetProjectByNameExecute(r admin.GetProjectByNameApiRequest) (*admin.Group, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetProjectByNameExecute") - } - - var r0 *admin.Group - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetProjectByNameApiRequest) (*admin.Group, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetProjectByNameApiRequest) *admin.Group); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.Group) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetProjectByNameApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetProjectByNameApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_GetProjectByNameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectByNameExecute' -type ProjectsApi_GetProjectByNameExecute_Call struct { - *mock.Call -} - -// GetProjectByNameExecute is a helper method to define mock.On call -// - r admin.GetProjectByNameApiRequest -func (_e *ProjectsApi_Expecter) GetProjectByNameExecute(r interface{}) *ProjectsApi_GetProjectByNameExecute_Call { - return &ProjectsApi_GetProjectByNameExecute_Call{Call: _e.mock.On("GetProjectByNameExecute", r)} -} - -func (_c *ProjectsApi_GetProjectByNameExecute_Call) Run(run func(r admin.GetProjectByNameApiRequest)) *ProjectsApi_GetProjectByNameExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetProjectByNameApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectByNameExecute_Call) Return(_a0 *admin.Group, _a1 *http.Response, _a2 error) *ProjectsApi_GetProjectByNameExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_GetProjectByNameExecute_Call) RunAndReturn(run func(admin.GetProjectByNameApiRequest) (*admin.Group, *http.Response, error)) *ProjectsApi_GetProjectByNameExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectByNameWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) GetProjectByNameWithParams(ctx context.Context, args *admin.GetProjectByNameApiParams) admin.GetProjectByNameApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetProjectByNameWithParams") - } - - var r0 admin.GetProjectByNameApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectByNameApiParams) admin.GetProjectByNameApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetProjectByNameApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectByNameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectByNameWithParams' -type ProjectsApi_GetProjectByNameWithParams_Call struct { - *mock.Call -} - -// GetProjectByNameWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetProjectByNameApiParams -func (_e *ProjectsApi_Expecter) GetProjectByNameWithParams(ctx interface{}, args interface{}) *ProjectsApi_GetProjectByNameWithParams_Call { - return &ProjectsApi_GetProjectByNameWithParams_Call{Call: _e.mock.On("GetProjectByNameWithParams", ctx, args)} -} - -func (_c *ProjectsApi_GetProjectByNameWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectByNameApiParams)) *ProjectsApi_GetProjectByNameWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetProjectByNameApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectByNameWithParams_Call) Return(_a0 admin.GetProjectByNameApiRequest) *ProjectsApi_GetProjectByNameWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectByNameWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectByNameApiParams) admin.GetProjectByNameApiRequest) *ProjectsApi_GetProjectByNameWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectExecute provides a mock function with given fields: r -func (_m *ProjectsApi) GetProjectExecute(r admin.GetProjectApiRequest) (*admin.Group, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetProjectExecute") - } - - var r0 *admin.Group - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetProjectApiRequest) (*admin.Group, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetProjectApiRequest) *admin.Group); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.Group) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_GetProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectExecute' -type ProjectsApi_GetProjectExecute_Call struct { - *mock.Call -} - -// GetProjectExecute is a helper method to define mock.On call -// - r admin.GetProjectApiRequest -func (_e *ProjectsApi_Expecter) GetProjectExecute(r interface{}) *ProjectsApi_GetProjectExecute_Call { - return &ProjectsApi_GetProjectExecute_Call{Call: _e.mock.On("GetProjectExecute", r)} -} - -func (_c *ProjectsApi_GetProjectExecute_Call) Run(run func(r admin.GetProjectApiRequest)) *ProjectsApi_GetProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetProjectApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectExecute_Call) Return(_a0 *admin.Group, _a1 *http.Response, _a2 error) *ProjectsApi_GetProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_GetProjectExecute_Call) RunAndReturn(run func(admin.GetProjectApiRequest) (*admin.Group, *http.Response, error)) *ProjectsApi_GetProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectInvitation provides a mock function with given fields: ctx, groupId, invitationId -func (_m *ProjectsApi) GetProjectInvitation(ctx context.Context, groupId string, invitationId string) admin.GetProjectInvitationApiRequest { - ret := _m.Called(ctx, groupId, invitationId) - - if len(ret) == 0 { - panic("no return value specified for GetProjectInvitation") - } - - var r0 admin.GetProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetProjectInvitationApiRequest); ok { - r0 = rf(ctx, groupId, invitationId) - } else { - r0 = ret.Get(0).(admin.GetProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectInvitation' -type ProjectsApi_GetProjectInvitation_Call struct { - *mock.Call -} - -// GetProjectInvitation is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - invitationId string -func (_e *ProjectsApi_Expecter) GetProjectInvitation(ctx interface{}, groupId interface{}, invitationId interface{}) *ProjectsApi_GetProjectInvitation_Call { - return &ProjectsApi_GetProjectInvitation_Call{Call: _e.mock.On("GetProjectInvitation", ctx, groupId, invitationId)} -} - -func (_c *ProjectsApi_GetProjectInvitation_Call) Run(run func(ctx context.Context, groupId string, invitationId string)) *ProjectsApi_GetProjectInvitation_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitation_Call) Return(_a0 admin.GetProjectInvitationApiRequest) *ProjectsApi_GetProjectInvitation_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitation_Call) RunAndReturn(run func(context.Context, string, string) admin.GetProjectInvitationApiRequest) *ProjectsApi_GetProjectInvitation_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectInvitationExecute provides a mock function with given fields: r -func (_m *ProjectsApi) GetProjectInvitationExecute(r admin.GetProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetProjectInvitationExecute") - } - - var r0 *admin.GroupInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetProjectInvitationApiRequest) *admin.GroupInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetProjectInvitationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetProjectInvitationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_GetProjectInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectInvitationExecute' -type ProjectsApi_GetProjectInvitationExecute_Call struct { - *mock.Call -} - -// GetProjectInvitationExecute is a helper method to define mock.On call -// - r admin.GetProjectInvitationApiRequest -func (_e *ProjectsApi_Expecter) GetProjectInvitationExecute(r interface{}) *ProjectsApi_GetProjectInvitationExecute_Call { - return &ProjectsApi_GetProjectInvitationExecute_Call{Call: _e.mock.On("GetProjectInvitationExecute", r)} -} - -func (_c *ProjectsApi_GetProjectInvitationExecute_Call) Run(run func(r admin.GetProjectInvitationApiRequest)) *ProjectsApi_GetProjectInvitationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetProjectInvitationApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitationExecute_Call) Return(_a0 *admin.GroupInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_GetProjectInvitationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitationExecute_Call) RunAndReturn(run func(admin.GetProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)) *ProjectsApi_GetProjectInvitationExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectInvitationWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) GetProjectInvitationWithParams(ctx context.Context, args *admin.GetProjectInvitationApiParams) admin.GetProjectInvitationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetProjectInvitationWithParams") - } - - var r0 admin.GetProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectInvitationApiParams) admin.GetProjectInvitationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectInvitationWithParams' -type ProjectsApi_GetProjectInvitationWithParams_Call struct { - *mock.Call -} - -// GetProjectInvitationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetProjectInvitationApiParams -func (_e *ProjectsApi_Expecter) GetProjectInvitationWithParams(ctx interface{}, args interface{}) *ProjectsApi_GetProjectInvitationWithParams_Call { - return &ProjectsApi_GetProjectInvitationWithParams_Call{Call: _e.mock.On("GetProjectInvitationWithParams", ctx, args)} -} - -func (_c *ProjectsApi_GetProjectInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectInvitationApiParams)) *ProjectsApi_GetProjectInvitationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetProjectInvitationApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitationWithParams_Call) Return(_a0 admin.GetProjectInvitationApiRequest) *ProjectsApi_GetProjectInvitationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectInvitationApiParams) admin.GetProjectInvitationApiRequest) *ProjectsApi_GetProjectInvitationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectLimit provides a mock function with given fields: ctx, limitName, groupId -func (_m *ProjectsApi) GetProjectLimit(ctx context.Context, limitName string, groupId string) admin.GetProjectLimitApiRequest { - ret := _m.Called(ctx, limitName, groupId) - - if len(ret) == 0 { - panic("no return value specified for GetProjectLimit") - } - - var r0 admin.GetProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetProjectLimitApiRequest); ok { - r0 = rf(ctx, limitName, groupId) - } else { - r0 = ret.Get(0).(admin.GetProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectLimit' -type ProjectsApi_GetProjectLimit_Call struct { - *mock.Call -} - -// GetProjectLimit is a helper method to define mock.On call -// - ctx context.Context -// - limitName string -// - groupId string -func (_e *ProjectsApi_Expecter) GetProjectLimit(ctx interface{}, limitName interface{}, groupId interface{}) *ProjectsApi_GetProjectLimit_Call { - return &ProjectsApi_GetProjectLimit_Call{Call: _e.mock.On("GetProjectLimit", ctx, limitName, groupId)} -} - -func (_c *ProjectsApi_GetProjectLimit_Call) Run(run func(ctx context.Context, limitName string, groupId string)) *ProjectsApi_GetProjectLimit_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectLimit_Call) Return(_a0 admin.GetProjectLimitApiRequest) *ProjectsApi_GetProjectLimit_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectLimit_Call) RunAndReturn(run func(context.Context, string, string) admin.GetProjectLimitApiRequest) *ProjectsApi_GetProjectLimit_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectLimitExecute provides a mock function with given fields: r -func (_m *ProjectsApi) GetProjectLimitExecute(r admin.GetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetProjectLimitExecute") - } - - var r0 *admin.DataFederationLimit - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetProjectLimitApiRequest) *admin.DataFederationLimit); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.DataFederationLimit) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetProjectLimitApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetProjectLimitApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_GetProjectLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectLimitExecute' -type ProjectsApi_GetProjectLimitExecute_Call struct { - *mock.Call -} - -// GetProjectLimitExecute is a helper method to define mock.On call -// - r admin.GetProjectLimitApiRequest -func (_e *ProjectsApi_Expecter) GetProjectLimitExecute(r interface{}) *ProjectsApi_GetProjectLimitExecute_Call { - return &ProjectsApi_GetProjectLimitExecute_Call{Call: _e.mock.On("GetProjectLimitExecute", r)} -} - -func (_c *ProjectsApi_GetProjectLimitExecute_Call) Run(run func(r admin.GetProjectLimitApiRequest)) *ProjectsApi_GetProjectLimitExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetProjectLimitApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectLimitExecute_Call) Return(_a0 *admin.DataFederationLimit, _a1 *http.Response, _a2 error) *ProjectsApi_GetProjectLimitExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_GetProjectLimitExecute_Call) RunAndReturn(run func(admin.GetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error)) *ProjectsApi_GetProjectLimitExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectLimitWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) GetProjectLimitWithParams(ctx context.Context, args *admin.GetProjectLimitApiParams) admin.GetProjectLimitApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetProjectLimitWithParams") - } - - var r0 admin.GetProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectLimitApiParams) admin.GetProjectLimitApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectLimitWithParams' -type ProjectsApi_GetProjectLimitWithParams_Call struct { - *mock.Call -} - -// GetProjectLimitWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetProjectLimitApiParams -func (_e *ProjectsApi_Expecter) GetProjectLimitWithParams(ctx interface{}, args interface{}) *ProjectsApi_GetProjectLimitWithParams_Call { - return &ProjectsApi_GetProjectLimitWithParams_Call{Call: _e.mock.On("GetProjectLimitWithParams", ctx, args)} -} - -func (_c *ProjectsApi_GetProjectLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectLimitApiParams)) *ProjectsApi_GetProjectLimitWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetProjectLimitApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectLimitWithParams_Call) Return(_a0 admin.GetProjectLimitApiRequest) *ProjectsApi_GetProjectLimitWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectLimitApiParams) admin.GetProjectLimitApiRequest) *ProjectsApi_GetProjectLimitWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectSettings provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) GetProjectSettings(ctx context.Context, groupId string) admin.GetProjectSettingsApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for GetProjectSettings") - } - - var r0 admin.GetProjectSettingsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetProjectSettingsApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.GetProjectSettingsApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectSettings' -type ProjectsApi_GetProjectSettings_Call struct { - *mock.Call -} - -// GetProjectSettings is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) GetProjectSettings(ctx interface{}, groupId interface{}) *ProjectsApi_GetProjectSettings_Call { - return &ProjectsApi_GetProjectSettings_Call{Call: _e.mock.On("GetProjectSettings", ctx, groupId)} -} - -func (_c *ProjectsApi_GetProjectSettings_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_GetProjectSettings_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectSettings_Call) Return(_a0 admin.GetProjectSettingsApiRequest) *ProjectsApi_GetProjectSettings_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectSettings_Call) RunAndReturn(run func(context.Context, string) admin.GetProjectSettingsApiRequest) *ProjectsApi_GetProjectSettings_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectSettingsExecute provides a mock function with given fields: r -func (_m *ProjectsApi) GetProjectSettingsExecute(r admin.GetProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetProjectSettingsExecute") - } - - var r0 *admin.GroupSettings - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetProjectSettingsApiRequest) *admin.GroupSettings); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupSettings) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetProjectSettingsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetProjectSettingsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_GetProjectSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectSettingsExecute' -type ProjectsApi_GetProjectSettingsExecute_Call struct { - *mock.Call -} - -// GetProjectSettingsExecute is a helper method to define mock.On call -// - r admin.GetProjectSettingsApiRequest -func (_e *ProjectsApi_Expecter) GetProjectSettingsExecute(r interface{}) *ProjectsApi_GetProjectSettingsExecute_Call { - return &ProjectsApi_GetProjectSettingsExecute_Call{Call: _e.mock.On("GetProjectSettingsExecute", r)} -} - -func (_c *ProjectsApi_GetProjectSettingsExecute_Call) Run(run func(r admin.GetProjectSettingsApiRequest)) *ProjectsApi_GetProjectSettingsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetProjectSettingsApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectSettingsExecute_Call) Return(_a0 *admin.GroupSettings, _a1 *http.Response, _a2 error) *ProjectsApi_GetProjectSettingsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_GetProjectSettingsExecute_Call) RunAndReturn(run func(admin.GetProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error)) *ProjectsApi_GetProjectSettingsExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectSettingsWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) GetProjectSettingsWithParams(ctx context.Context, args *admin.GetProjectSettingsApiParams) admin.GetProjectSettingsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetProjectSettingsWithParams") - } - - var r0 admin.GetProjectSettingsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectSettingsApiParams) admin.GetProjectSettingsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetProjectSettingsApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectSettingsWithParams' -type ProjectsApi_GetProjectSettingsWithParams_Call struct { - *mock.Call -} - -// GetProjectSettingsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetProjectSettingsApiParams -func (_e *ProjectsApi_Expecter) GetProjectSettingsWithParams(ctx interface{}, args interface{}) *ProjectsApi_GetProjectSettingsWithParams_Call { - return &ProjectsApi_GetProjectSettingsWithParams_Call{Call: _e.mock.On("GetProjectSettingsWithParams", ctx, args)} -} - -func (_c *ProjectsApi_GetProjectSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectSettingsApiParams)) *ProjectsApi_GetProjectSettingsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetProjectSettingsApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectSettingsWithParams_Call) Return(_a0 admin.GetProjectSettingsApiRequest) *ProjectsApi_GetProjectSettingsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectSettingsApiParams) admin.GetProjectSettingsApiRequest) *ProjectsApi_GetProjectSettingsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetProjectWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) GetProjectWithParams(ctx context.Context, args *admin.GetProjectApiParams) admin.GetProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetProjectWithParams") - } - - var r0 admin.GetProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectApiParams) admin.GetProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_GetProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectWithParams' -type ProjectsApi_GetProjectWithParams_Call struct { - *mock.Call -} - -// GetProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetProjectApiParams -func (_e *ProjectsApi_Expecter) GetProjectWithParams(ctx interface{}, args interface{}) *ProjectsApi_GetProjectWithParams_Call { - return &ProjectsApi_GetProjectWithParams_Call{Call: _e.mock.On("GetProjectWithParams", ctx, args)} -} - -func (_c *ProjectsApi_GetProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectApiParams)) *ProjectsApi_GetProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetProjectApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_GetProjectWithParams_Call) Return(_a0 admin.GetProjectApiRequest) *ProjectsApi_GetProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_GetProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectApiParams) admin.GetProjectApiRequest) *ProjectsApi_GetProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectInvitations provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) ListProjectInvitations(ctx context.Context, groupId string) admin.ListProjectInvitationsApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListProjectInvitations") - } - - var r0 admin.ListProjectInvitationsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectInvitationsApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListProjectInvitationsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectInvitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectInvitations' -type ProjectsApi_ListProjectInvitations_Call struct { - *mock.Call -} - -// ListProjectInvitations is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) ListProjectInvitations(ctx interface{}, groupId interface{}) *ProjectsApi_ListProjectInvitations_Call { - return &ProjectsApi_ListProjectInvitations_Call{Call: _e.mock.On("ListProjectInvitations", ctx, groupId)} -} - -func (_c *ProjectsApi_ListProjectInvitations_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_ListProjectInvitations_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitations_Call) Return(_a0 admin.ListProjectInvitationsApiRequest) *ProjectsApi_ListProjectInvitations_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitations_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectInvitationsApiRequest) *ProjectsApi_ListProjectInvitations_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectInvitationsExecute provides a mock function with given fields: r -func (_m *ProjectsApi) ListProjectInvitationsExecute(r admin.ListProjectInvitationsApiRequest) ([]admin.GroupInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListProjectInvitationsExecute") - } - - var r0 []admin.GroupInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListProjectInvitationsApiRequest) ([]admin.GroupInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListProjectInvitationsApiRequest) []admin.GroupInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]admin.GroupInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListProjectInvitationsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListProjectInvitationsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_ListProjectInvitationsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectInvitationsExecute' -type ProjectsApi_ListProjectInvitationsExecute_Call struct { - *mock.Call -} - -// ListProjectInvitationsExecute is a helper method to define mock.On call -// - r admin.ListProjectInvitationsApiRequest -func (_e *ProjectsApi_Expecter) ListProjectInvitationsExecute(r interface{}) *ProjectsApi_ListProjectInvitationsExecute_Call { - return &ProjectsApi_ListProjectInvitationsExecute_Call{Call: _e.mock.On("ListProjectInvitationsExecute", r)} -} - -func (_c *ProjectsApi_ListProjectInvitationsExecute_Call) Run(run func(r admin.ListProjectInvitationsApiRequest)) *ProjectsApi_ListProjectInvitationsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListProjectInvitationsApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitationsExecute_Call) Return(_a0 []admin.GroupInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_ListProjectInvitationsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitationsExecute_Call) RunAndReturn(run func(admin.ListProjectInvitationsApiRequest) ([]admin.GroupInvitation, *http.Response, error)) *ProjectsApi_ListProjectInvitationsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectInvitationsWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) ListProjectInvitationsWithParams(ctx context.Context, args *admin.ListProjectInvitationsApiParams) admin.ListProjectInvitationsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListProjectInvitationsWithParams") - } - - var r0 admin.ListProjectInvitationsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectInvitationsApiParams) admin.ListProjectInvitationsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListProjectInvitationsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectInvitationsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectInvitationsWithParams' -type ProjectsApi_ListProjectInvitationsWithParams_Call struct { - *mock.Call -} - -// ListProjectInvitationsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListProjectInvitationsApiParams -func (_e *ProjectsApi_Expecter) ListProjectInvitationsWithParams(ctx interface{}, args interface{}) *ProjectsApi_ListProjectInvitationsWithParams_Call { - return &ProjectsApi_ListProjectInvitationsWithParams_Call{Call: _e.mock.On("ListProjectInvitationsWithParams", ctx, args)} -} - -func (_c *ProjectsApi_ListProjectInvitationsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectInvitationsApiParams)) *ProjectsApi_ListProjectInvitationsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListProjectInvitationsApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitationsWithParams_Call) Return(_a0 admin.ListProjectInvitationsApiRequest) *ProjectsApi_ListProjectInvitationsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectInvitationsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectInvitationsApiParams) admin.ListProjectInvitationsApiRequest) *ProjectsApi_ListProjectInvitationsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectLimits provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) ListProjectLimits(ctx context.Context, groupId string) admin.ListProjectLimitsApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListProjectLimits") - } - - var r0 admin.ListProjectLimitsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectLimitsApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListProjectLimitsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectLimits' -type ProjectsApi_ListProjectLimits_Call struct { - *mock.Call -} - -// ListProjectLimits is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) ListProjectLimits(ctx interface{}, groupId interface{}) *ProjectsApi_ListProjectLimits_Call { - return &ProjectsApi_ListProjectLimits_Call{Call: _e.mock.On("ListProjectLimits", ctx, groupId)} -} - -func (_c *ProjectsApi_ListProjectLimits_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_ListProjectLimits_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectLimits_Call) Return(_a0 admin.ListProjectLimitsApiRequest) *ProjectsApi_ListProjectLimits_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectLimits_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectLimitsApiRequest) *ProjectsApi_ListProjectLimits_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectLimitsExecute provides a mock function with given fields: r -func (_m *ProjectsApi) ListProjectLimitsExecute(r admin.ListProjectLimitsApiRequest) ([]admin.DataFederationLimit, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListProjectLimitsExecute") - } - - var r0 []admin.DataFederationLimit - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListProjectLimitsApiRequest) ([]admin.DataFederationLimit, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListProjectLimitsApiRequest) []admin.DataFederationLimit); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]admin.DataFederationLimit) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListProjectLimitsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListProjectLimitsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_ListProjectLimitsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectLimitsExecute' -type ProjectsApi_ListProjectLimitsExecute_Call struct { - *mock.Call -} - -// ListProjectLimitsExecute is a helper method to define mock.On call -// - r admin.ListProjectLimitsApiRequest -func (_e *ProjectsApi_Expecter) ListProjectLimitsExecute(r interface{}) *ProjectsApi_ListProjectLimitsExecute_Call { - return &ProjectsApi_ListProjectLimitsExecute_Call{Call: _e.mock.On("ListProjectLimitsExecute", r)} -} - -func (_c *ProjectsApi_ListProjectLimitsExecute_Call) Run(run func(r admin.ListProjectLimitsApiRequest)) *ProjectsApi_ListProjectLimitsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListProjectLimitsApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectLimitsExecute_Call) Return(_a0 []admin.DataFederationLimit, _a1 *http.Response, _a2 error) *ProjectsApi_ListProjectLimitsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_ListProjectLimitsExecute_Call) RunAndReturn(run func(admin.ListProjectLimitsApiRequest) ([]admin.DataFederationLimit, *http.Response, error)) *ProjectsApi_ListProjectLimitsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectLimitsWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) ListProjectLimitsWithParams(ctx context.Context, args *admin.ListProjectLimitsApiParams) admin.ListProjectLimitsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListProjectLimitsWithParams") - } - - var r0 admin.ListProjectLimitsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectLimitsApiParams) admin.ListProjectLimitsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListProjectLimitsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectLimitsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectLimitsWithParams' -type ProjectsApi_ListProjectLimitsWithParams_Call struct { - *mock.Call -} - -// ListProjectLimitsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListProjectLimitsApiParams -func (_e *ProjectsApi_Expecter) ListProjectLimitsWithParams(ctx interface{}, args interface{}) *ProjectsApi_ListProjectLimitsWithParams_Call { - return &ProjectsApi_ListProjectLimitsWithParams_Call{Call: _e.mock.On("ListProjectLimitsWithParams", ctx, args)} -} - -func (_c *ProjectsApi_ListProjectLimitsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectLimitsApiParams)) *ProjectsApi_ListProjectLimitsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListProjectLimitsApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectLimitsWithParams_Call) Return(_a0 admin.ListProjectLimitsApiRequest) *ProjectsApi_ListProjectLimitsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectLimitsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectLimitsApiParams) admin.ListProjectLimitsApiRequest) *ProjectsApi_ListProjectLimitsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectUsers provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) ListProjectUsers(ctx context.Context, groupId string) admin.ListProjectUsersApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListProjectUsers") - } - - var r0 admin.ListProjectUsersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectUsersApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListProjectUsersApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectUsers' -type ProjectsApi_ListProjectUsers_Call struct { - *mock.Call -} - -// ListProjectUsers is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) ListProjectUsers(ctx interface{}, groupId interface{}) *ProjectsApi_ListProjectUsers_Call { - return &ProjectsApi_ListProjectUsers_Call{Call: _e.mock.On("ListProjectUsers", ctx, groupId)} -} - -func (_c *ProjectsApi_ListProjectUsers_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_ListProjectUsers_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectUsers_Call) Return(_a0 admin.ListProjectUsersApiRequest) *ProjectsApi_ListProjectUsers_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectUsers_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectUsersApiRequest) *ProjectsApi_ListProjectUsers_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectUsersExecute provides a mock function with given fields: r -func (_m *ProjectsApi) ListProjectUsersExecute(r admin.ListProjectUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListProjectUsersExecute") - } - - var r0 *admin.PaginatedAppUser - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListProjectUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListProjectUsersApiRequest) *admin.PaginatedAppUser); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedAppUser) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListProjectUsersApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListProjectUsersApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_ListProjectUsersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectUsersExecute' -type ProjectsApi_ListProjectUsersExecute_Call struct { - *mock.Call -} - -// ListProjectUsersExecute is a helper method to define mock.On call -// - r admin.ListProjectUsersApiRequest -func (_e *ProjectsApi_Expecter) ListProjectUsersExecute(r interface{}) *ProjectsApi_ListProjectUsersExecute_Call { - return &ProjectsApi_ListProjectUsersExecute_Call{Call: _e.mock.On("ListProjectUsersExecute", r)} -} - -func (_c *ProjectsApi_ListProjectUsersExecute_Call) Run(run func(r admin.ListProjectUsersApiRequest)) *ProjectsApi_ListProjectUsersExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListProjectUsersApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectUsersExecute_Call) Return(_a0 *admin.PaginatedAppUser, _a1 *http.Response, _a2 error) *ProjectsApi_ListProjectUsersExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_ListProjectUsersExecute_Call) RunAndReturn(run func(admin.ListProjectUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error)) *ProjectsApi_ListProjectUsersExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectUsersWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) ListProjectUsersWithParams(ctx context.Context, args *admin.ListProjectUsersApiParams) admin.ListProjectUsersApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListProjectUsersWithParams") - } - - var r0 admin.ListProjectUsersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectUsersApiParams) admin.ListProjectUsersApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListProjectUsersApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectUsersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectUsersWithParams' -type ProjectsApi_ListProjectUsersWithParams_Call struct { - *mock.Call -} - -// ListProjectUsersWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListProjectUsersApiParams -func (_e *ProjectsApi_Expecter) ListProjectUsersWithParams(ctx interface{}, args interface{}) *ProjectsApi_ListProjectUsersWithParams_Call { - return &ProjectsApi_ListProjectUsersWithParams_Call{Call: _e.mock.On("ListProjectUsersWithParams", ctx, args)} -} - -func (_c *ProjectsApi_ListProjectUsersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectUsersApiParams)) *ProjectsApi_ListProjectUsersWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListProjectUsersApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectUsersWithParams_Call) Return(_a0 admin.ListProjectUsersApiRequest) *ProjectsApi_ListProjectUsersWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectUsersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectUsersApiParams) admin.ListProjectUsersApiRequest) *ProjectsApi_ListProjectUsersWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjects provides a mock function with given fields: ctx -func (_m *ProjectsApi) ListProjects(ctx context.Context) admin.ListProjectsApiRequest { - ret := _m.Called(ctx) - - if len(ret) == 0 { - panic("no return value specified for ListProjects") - } - - var r0 admin.ListProjectsApiRequest - if rf, ok := ret.Get(0).(func(context.Context) admin.ListProjectsApiRequest); ok { - r0 = rf(ctx) - } else { - r0 = ret.Get(0).(admin.ListProjectsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjects' -type ProjectsApi_ListProjects_Call struct { - *mock.Call -} - -// ListProjects is a helper method to define mock.On call -// - ctx context.Context -func (_e *ProjectsApi_Expecter) ListProjects(ctx interface{}) *ProjectsApi_ListProjects_Call { - return &ProjectsApi_ListProjects_Call{Call: _e.mock.On("ListProjects", ctx)} -} - -func (_c *ProjectsApi_ListProjects_Call) Run(run func(ctx context.Context)) *ProjectsApi_ListProjects_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjects_Call) Return(_a0 admin.ListProjectsApiRequest) *ProjectsApi_ListProjects_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjects_Call) RunAndReturn(run func(context.Context) admin.ListProjectsApiRequest) *ProjectsApi_ListProjects_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectsExecute provides a mock function with given fields: r -func (_m *ProjectsApi) ListProjectsExecute(r admin.ListProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListProjectsExecute") - } - - var r0 *admin.PaginatedAtlasGroup - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListProjectsApiRequest) *admin.PaginatedAtlasGroup); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedAtlasGroup) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListProjectsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListProjectsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_ListProjectsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectsExecute' -type ProjectsApi_ListProjectsExecute_Call struct { - *mock.Call -} - -// ListProjectsExecute is a helper method to define mock.On call -// - r admin.ListProjectsApiRequest -func (_e *ProjectsApi_Expecter) ListProjectsExecute(r interface{}) *ProjectsApi_ListProjectsExecute_Call { - return &ProjectsApi_ListProjectsExecute_Call{Call: _e.mock.On("ListProjectsExecute", r)} -} - -func (_c *ProjectsApi_ListProjectsExecute_Call) Run(run func(r admin.ListProjectsApiRequest)) *ProjectsApi_ListProjectsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListProjectsApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectsExecute_Call) Return(_a0 *admin.PaginatedAtlasGroup, _a1 *http.Response, _a2 error) *ProjectsApi_ListProjectsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_ListProjectsExecute_Call) RunAndReturn(run func(admin.ListProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error)) *ProjectsApi_ListProjectsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectsWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) ListProjectsWithParams(ctx context.Context, args *admin.ListProjectsApiParams) admin.ListProjectsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListProjectsWithParams") - } - - var r0 admin.ListProjectsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectsApiParams) admin.ListProjectsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListProjectsApiRequest) - } - - return r0 -} - -// ProjectsApi_ListProjectsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectsWithParams' -type ProjectsApi_ListProjectsWithParams_Call struct { - *mock.Call -} - -// ListProjectsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListProjectsApiParams -func (_e *ProjectsApi_Expecter) ListProjectsWithParams(ctx interface{}, args interface{}) *ProjectsApi_ListProjectsWithParams_Call { - return &ProjectsApi_ListProjectsWithParams_Call{Call: _e.mock.On("ListProjectsWithParams", ctx, args)} -} - -func (_c *ProjectsApi_ListProjectsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectsApiParams)) *ProjectsApi_ListProjectsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListProjectsApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_ListProjectsWithParams_Call) Return(_a0 admin.ListProjectsApiRequest) *ProjectsApi_ListProjectsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ListProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectsApiParams) admin.ListProjectsApiRequest) *ProjectsApi_ListProjectsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectUser provides a mock function with given fields: ctx, groupId, userId -func (_m *ProjectsApi) RemoveProjectUser(ctx context.Context, groupId string, userId string) admin.RemoveProjectUserApiRequest { - ret := _m.Called(ctx, groupId, userId) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectUser") - } - - var r0 admin.RemoveProjectUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveProjectUserApiRequest); ok { - r0 = rf(ctx, groupId, userId) - } else { - r0 = ret.Get(0).(admin.RemoveProjectUserApiRequest) - } - - return r0 -} - -// ProjectsApi_RemoveProjectUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectUser' -type ProjectsApi_RemoveProjectUser_Call struct { - *mock.Call -} - -// RemoveProjectUser is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - userId string -func (_e *ProjectsApi_Expecter) RemoveProjectUser(ctx interface{}, groupId interface{}, userId interface{}) *ProjectsApi_RemoveProjectUser_Call { - return &ProjectsApi_RemoveProjectUser_Call{Call: _e.mock.On("RemoveProjectUser", ctx, groupId, userId)} -} - -func (_c *ProjectsApi_RemoveProjectUser_Call) Run(run func(ctx context.Context, groupId string, userId string)) *ProjectsApi_RemoveProjectUser_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUser_Call) Return(_a0 admin.RemoveProjectUserApiRequest) *ProjectsApi_RemoveProjectUser_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUser_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveProjectUserApiRequest) *ProjectsApi_RemoveProjectUser_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectUserExecute provides a mock function with given fields: r -func (_m *ProjectsApi) RemoveProjectUserExecute(r admin.RemoveProjectUserApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectUserExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.RemoveProjectUserApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.RemoveProjectUserApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.RemoveProjectUserApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// ProjectsApi_RemoveProjectUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectUserExecute' -type ProjectsApi_RemoveProjectUserExecute_Call struct { - *mock.Call -} - -// RemoveProjectUserExecute is a helper method to define mock.On call -// - r admin.RemoveProjectUserApiRequest -func (_e *ProjectsApi_Expecter) RemoveProjectUserExecute(r interface{}) *ProjectsApi_RemoveProjectUserExecute_Call { - return &ProjectsApi_RemoveProjectUserExecute_Call{Call: _e.mock.On("RemoveProjectUserExecute", r)} -} - -func (_c *ProjectsApi_RemoveProjectUserExecute_Call) Run(run func(r admin.RemoveProjectUserApiRequest)) *ProjectsApi_RemoveProjectUserExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.RemoveProjectUserApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUserExecute_Call) Return(_a0 *http.Response, _a1 error) *ProjectsApi_RemoveProjectUserExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUserExecute_Call) RunAndReturn(run func(admin.RemoveProjectUserApiRequest) (*http.Response, error)) *ProjectsApi_RemoveProjectUserExecute_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectUserWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) RemoveProjectUserWithParams(ctx context.Context, args *admin.RemoveProjectUserApiParams) admin.RemoveProjectUserApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectUserWithParams") - } - - var r0 admin.RemoveProjectUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveProjectUserApiParams) admin.RemoveProjectUserApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.RemoveProjectUserApiRequest) - } - - return r0 -} - -// ProjectsApi_RemoveProjectUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectUserWithParams' -type ProjectsApi_RemoveProjectUserWithParams_Call struct { - *mock.Call -} - -// RemoveProjectUserWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.RemoveProjectUserApiParams -func (_e *ProjectsApi_Expecter) RemoveProjectUserWithParams(ctx interface{}, args interface{}) *ProjectsApi_RemoveProjectUserWithParams_Call { - return &ProjectsApi_RemoveProjectUserWithParams_Call{Call: _e.mock.On("RemoveProjectUserWithParams", ctx, args)} -} - -func (_c *ProjectsApi_RemoveProjectUserWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveProjectUserApiParams)) *ProjectsApi_RemoveProjectUserWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.RemoveProjectUserApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUserWithParams_Call) Return(_a0 admin.RemoveProjectUserApiRequest) *ProjectsApi_RemoveProjectUserWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_RemoveProjectUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveProjectUserApiParams) admin.RemoveProjectUserApiRequest) *ProjectsApi_RemoveProjectUserWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ReturnAllIPAddresses provides a mock function with given fields: ctx, groupId -func (_m *ProjectsApi) ReturnAllIPAddresses(ctx context.Context, groupId string) admin.ReturnAllIPAddressesApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ReturnAllIPAddresses") - } - - var r0 admin.ReturnAllIPAddressesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ReturnAllIPAddressesApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ReturnAllIPAddressesApiRequest) - } - - return r0 -} - -// ProjectsApi_ReturnAllIPAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllIPAddresses' -type ProjectsApi_ReturnAllIPAddresses_Call struct { - *mock.Call -} - -// ReturnAllIPAddresses is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *ProjectsApi_Expecter) ReturnAllIPAddresses(ctx interface{}, groupId interface{}) *ProjectsApi_ReturnAllIPAddresses_Call { - return &ProjectsApi_ReturnAllIPAddresses_Call{Call: _e.mock.On("ReturnAllIPAddresses", ctx, groupId)} -} - -func (_c *ProjectsApi_ReturnAllIPAddresses_Call) Run(run func(ctx context.Context, groupId string)) *ProjectsApi_ReturnAllIPAddresses_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddresses_Call) Return(_a0 admin.ReturnAllIPAddressesApiRequest) *ProjectsApi_ReturnAllIPAddresses_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddresses_Call) RunAndReturn(run func(context.Context, string) admin.ReturnAllIPAddressesApiRequest) *ProjectsApi_ReturnAllIPAddresses_Call { - _c.Call.Return(run) - return _c -} - -// ReturnAllIPAddressesExecute provides a mock function with given fields: r -func (_m *ProjectsApi) ReturnAllIPAddressesExecute(r admin.ReturnAllIPAddressesApiRequest) (*admin.GroupIPAddresses, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ReturnAllIPAddressesExecute") - } - - var r0 *admin.GroupIPAddresses - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ReturnAllIPAddressesApiRequest) (*admin.GroupIPAddresses, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ReturnAllIPAddressesApiRequest) *admin.GroupIPAddresses); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupIPAddresses) - } - } - - if rf, ok := ret.Get(1).(func(admin.ReturnAllIPAddressesApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ReturnAllIPAddressesApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_ReturnAllIPAddressesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllIPAddressesExecute' -type ProjectsApi_ReturnAllIPAddressesExecute_Call struct { - *mock.Call -} - -// ReturnAllIPAddressesExecute is a helper method to define mock.On call -// - r admin.ReturnAllIPAddressesApiRequest -func (_e *ProjectsApi_Expecter) ReturnAllIPAddressesExecute(r interface{}) *ProjectsApi_ReturnAllIPAddressesExecute_Call { - return &ProjectsApi_ReturnAllIPAddressesExecute_Call{Call: _e.mock.On("ReturnAllIPAddressesExecute", r)} -} - -func (_c *ProjectsApi_ReturnAllIPAddressesExecute_Call) Run(run func(r admin.ReturnAllIPAddressesApiRequest)) *ProjectsApi_ReturnAllIPAddressesExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ReturnAllIPAddressesApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddressesExecute_Call) Return(_a0 *admin.GroupIPAddresses, _a1 *http.Response, _a2 error) *ProjectsApi_ReturnAllIPAddressesExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddressesExecute_Call) RunAndReturn(run func(admin.ReturnAllIPAddressesApiRequest) (*admin.GroupIPAddresses, *http.Response, error)) *ProjectsApi_ReturnAllIPAddressesExecute_Call { - _c.Call.Return(run) - return _c -} - -// ReturnAllIPAddressesWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) ReturnAllIPAddressesWithParams(ctx context.Context, args *admin.ReturnAllIPAddressesApiParams) admin.ReturnAllIPAddressesApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ReturnAllIPAddressesWithParams") - } - - var r0 admin.ReturnAllIPAddressesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnAllIPAddressesApiParams) admin.ReturnAllIPAddressesApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ReturnAllIPAddressesApiRequest) - } - - return r0 -} - -// ProjectsApi_ReturnAllIPAddressesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllIPAddressesWithParams' -type ProjectsApi_ReturnAllIPAddressesWithParams_Call struct { - *mock.Call -} - -// ReturnAllIPAddressesWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ReturnAllIPAddressesApiParams -func (_e *ProjectsApi_Expecter) ReturnAllIPAddressesWithParams(ctx interface{}, args interface{}) *ProjectsApi_ReturnAllIPAddressesWithParams_Call { - return &ProjectsApi_ReturnAllIPAddressesWithParams_Call{Call: _e.mock.On("ReturnAllIPAddressesWithParams", ctx, args)} -} - -func (_c *ProjectsApi_ReturnAllIPAddressesWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnAllIPAddressesApiParams)) *ProjectsApi_ReturnAllIPAddressesWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ReturnAllIPAddressesApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddressesWithParams_Call) Return(_a0 admin.ReturnAllIPAddressesApiRequest) *ProjectsApi_ReturnAllIPAddressesWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_ReturnAllIPAddressesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnAllIPAddressesApiParams) admin.ReturnAllIPAddressesApiRequest) *ProjectsApi_ReturnAllIPAddressesWithParams_Call { - _c.Call.Return(run) - return _c -} - -// SetProjectLimit provides a mock function with given fields: ctx, limitName, groupId, dataFederationLimit -func (_m *ProjectsApi) SetProjectLimit(ctx context.Context, limitName string, groupId string, dataFederationLimit *admin.DataFederationLimit) admin.SetProjectLimitApiRequest { - ret := _m.Called(ctx, limitName, groupId, dataFederationLimit) - - if len(ret) == 0 { - panic("no return value specified for SetProjectLimit") - } - - var r0 admin.SetProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DataFederationLimit) admin.SetProjectLimitApiRequest); ok { - r0 = rf(ctx, limitName, groupId, dataFederationLimit) - } else { - r0 = ret.Get(0).(admin.SetProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_SetProjectLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProjectLimit' -type ProjectsApi_SetProjectLimit_Call struct { - *mock.Call -} - -// SetProjectLimit is a helper method to define mock.On call -// - ctx context.Context -// - limitName string -// - groupId string -// - dataFederationLimit *admin.DataFederationLimit -func (_e *ProjectsApi_Expecter) SetProjectLimit(ctx interface{}, limitName interface{}, groupId interface{}, dataFederationLimit interface{}) *ProjectsApi_SetProjectLimit_Call { - return &ProjectsApi_SetProjectLimit_Call{Call: _e.mock.On("SetProjectLimit", ctx, limitName, groupId, dataFederationLimit)} -} - -func (_c *ProjectsApi_SetProjectLimit_Call) Run(run func(ctx context.Context, limitName string, groupId string, dataFederationLimit *admin.DataFederationLimit)) *ProjectsApi_SetProjectLimit_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DataFederationLimit)) - }) - return _c -} - -func (_c *ProjectsApi_SetProjectLimit_Call) Return(_a0 admin.SetProjectLimitApiRequest) *ProjectsApi_SetProjectLimit_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_SetProjectLimit_Call) RunAndReturn(run func(context.Context, string, string, *admin.DataFederationLimit) admin.SetProjectLimitApiRequest) *ProjectsApi_SetProjectLimit_Call { - _c.Call.Return(run) - return _c -} - -// SetProjectLimitExecute provides a mock function with given fields: r -func (_m *ProjectsApi) SetProjectLimitExecute(r admin.SetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for SetProjectLimitExecute") - } - - var r0 *admin.DataFederationLimit - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.SetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.SetProjectLimitApiRequest) *admin.DataFederationLimit); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.DataFederationLimit) - } - } - - if rf, ok := ret.Get(1).(func(admin.SetProjectLimitApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.SetProjectLimitApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_SetProjectLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProjectLimitExecute' -type ProjectsApi_SetProjectLimitExecute_Call struct { - *mock.Call -} - -// SetProjectLimitExecute is a helper method to define mock.On call -// - r admin.SetProjectLimitApiRequest -func (_e *ProjectsApi_Expecter) SetProjectLimitExecute(r interface{}) *ProjectsApi_SetProjectLimitExecute_Call { - return &ProjectsApi_SetProjectLimitExecute_Call{Call: _e.mock.On("SetProjectLimitExecute", r)} -} - -func (_c *ProjectsApi_SetProjectLimitExecute_Call) Run(run func(r admin.SetProjectLimitApiRequest)) *ProjectsApi_SetProjectLimitExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.SetProjectLimitApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_SetProjectLimitExecute_Call) Return(_a0 *admin.DataFederationLimit, _a1 *http.Response, _a2 error) *ProjectsApi_SetProjectLimitExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_SetProjectLimitExecute_Call) RunAndReturn(run func(admin.SetProjectLimitApiRequest) (*admin.DataFederationLimit, *http.Response, error)) *ProjectsApi_SetProjectLimitExecute_Call { - _c.Call.Return(run) - return _c -} - -// SetProjectLimitWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) SetProjectLimitWithParams(ctx context.Context, args *admin.SetProjectLimitApiParams) admin.SetProjectLimitApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for SetProjectLimitWithParams") - } - - var r0 admin.SetProjectLimitApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.SetProjectLimitApiParams) admin.SetProjectLimitApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.SetProjectLimitApiRequest) - } - - return r0 -} - -// ProjectsApi_SetProjectLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProjectLimitWithParams' -type ProjectsApi_SetProjectLimitWithParams_Call struct { - *mock.Call -} - -// SetProjectLimitWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.SetProjectLimitApiParams -func (_e *ProjectsApi_Expecter) SetProjectLimitWithParams(ctx interface{}, args interface{}) *ProjectsApi_SetProjectLimitWithParams_Call { - return &ProjectsApi_SetProjectLimitWithParams_Call{Call: _e.mock.On("SetProjectLimitWithParams", ctx, args)} -} - -func (_c *ProjectsApi_SetProjectLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.SetProjectLimitApiParams)) *ProjectsApi_SetProjectLimitWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.SetProjectLimitApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_SetProjectLimitWithParams_Call) Return(_a0 admin.SetProjectLimitApiRequest) *ProjectsApi_SetProjectLimitWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_SetProjectLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.SetProjectLimitApiParams) admin.SetProjectLimitApiRequest) *ProjectsApi_SetProjectLimitWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProject provides a mock function with given fields: ctx, groupId, groupUpdate -func (_m *ProjectsApi) UpdateProject(ctx context.Context, groupId string, groupUpdate *admin.GroupUpdate) admin.UpdateProjectApiRequest { - ret := _m.Called(ctx, groupId, groupUpdate) - - if len(ret) == 0 { - panic("no return value specified for UpdateProject") - } - - var r0 admin.UpdateProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupUpdate) admin.UpdateProjectApiRequest); ok { - r0 = rf(ctx, groupId, groupUpdate) - } else { - r0 = ret.Get(0).(admin.UpdateProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProject' -type ProjectsApi_UpdateProject_Call struct { - *mock.Call -} - -// UpdateProject is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - groupUpdate *admin.GroupUpdate -func (_e *ProjectsApi_Expecter) UpdateProject(ctx interface{}, groupId interface{}, groupUpdate interface{}) *ProjectsApi_UpdateProject_Call { - return &ProjectsApi_UpdateProject_Call{Call: _e.mock.On("UpdateProject", ctx, groupId, groupUpdate)} -} - -func (_c *ProjectsApi_UpdateProject_Call) Run(run func(ctx context.Context, groupId string, groupUpdate *admin.GroupUpdate)) *ProjectsApi_UpdateProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupUpdate)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProject_Call) Return(_a0 admin.UpdateProjectApiRequest) *ProjectsApi_UpdateProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProject_Call) RunAndReturn(run func(context.Context, string, *admin.GroupUpdate) admin.UpdateProjectApiRequest) *ProjectsApi_UpdateProject_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectExecute provides a mock function with given fields: r -func (_m *ProjectsApi) UpdateProjectExecute(r admin.UpdateProjectApiRequest) (*admin.Group, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectExecute") - } - - var r0 *admin.Group - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateProjectApiRequest) (*admin.Group, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateProjectApiRequest) *admin.Group); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.Group) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_UpdateProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectExecute' -type ProjectsApi_UpdateProjectExecute_Call struct { - *mock.Call -} - -// UpdateProjectExecute is a helper method to define mock.On call -// - r admin.UpdateProjectApiRequest -func (_e *ProjectsApi_Expecter) UpdateProjectExecute(r interface{}) *ProjectsApi_UpdateProjectExecute_Call { - return &ProjectsApi_UpdateProjectExecute_Call{Call: _e.mock.On("UpdateProjectExecute", r)} -} - -func (_c *ProjectsApi_UpdateProjectExecute_Call) Run(run func(r admin.UpdateProjectApiRequest)) *ProjectsApi_UpdateProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateProjectApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectExecute_Call) Return(_a0 *admin.Group, _a1 *http.Response, _a2 error) *ProjectsApi_UpdateProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_UpdateProjectExecute_Call) RunAndReturn(run func(admin.UpdateProjectApiRequest) (*admin.Group, *http.Response, error)) *ProjectsApi_UpdateProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitation provides a mock function with given fields: ctx, groupId, groupInvitationRequest -func (_m *ProjectsApi) UpdateProjectInvitation(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest) admin.UpdateProjectInvitationApiRequest { - ret := _m.Called(ctx, groupId, groupInvitationRequest) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitation") - } - - var r0 admin.UpdateProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupInvitationRequest) admin.UpdateProjectInvitationApiRequest); ok { - r0 = rf(ctx, groupId, groupInvitationRequest) - } else { - r0 = ret.Get(0).(admin.UpdateProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitation' -type ProjectsApi_UpdateProjectInvitation_Call struct { - *mock.Call -} - -// UpdateProjectInvitation is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - groupInvitationRequest *admin.GroupInvitationRequest -func (_e *ProjectsApi_Expecter) UpdateProjectInvitation(ctx interface{}, groupId interface{}, groupInvitationRequest interface{}) *ProjectsApi_UpdateProjectInvitation_Call { - return &ProjectsApi_UpdateProjectInvitation_Call{Call: _e.mock.On("UpdateProjectInvitation", ctx, groupId, groupInvitationRequest)} -} - -func (_c *ProjectsApi_UpdateProjectInvitation_Call) Run(run func(ctx context.Context, groupId string, groupInvitationRequest *admin.GroupInvitationRequest)) *ProjectsApi_UpdateProjectInvitation_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupInvitationRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitation_Call) Return(_a0 admin.UpdateProjectInvitationApiRequest) *ProjectsApi_UpdateProjectInvitation_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitation_Call) RunAndReturn(run func(context.Context, string, *admin.GroupInvitationRequest) admin.UpdateProjectInvitationApiRequest) *ProjectsApi_UpdateProjectInvitation_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitationById provides a mock function with given fields: ctx, groupId, invitationId, groupInvitationUpdateRequest -func (_m *ProjectsApi) UpdateProjectInvitationById(ctx context.Context, groupId string, invitationId string, groupInvitationUpdateRequest *admin.GroupInvitationUpdateRequest) admin.UpdateProjectInvitationByIdApiRequest { - ret := _m.Called(ctx, groupId, invitationId, groupInvitationUpdateRequest) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitationById") - } - - var r0 admin.UpdateProjectInvitationByIdApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.GroupInvitationUpdateRequest) admin.UpdateProjectInvitationByIdApiRequest); ok { - r0 = rf(ctx, groupId, invitationId, groupInvitationUpdateRequest) - } else { - r0 = ret.Get(0).(admin.UpdateProjectInvitationByIdApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectInvitationById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitationById' -type ProjectsApi_UpdateProjectInvitationById_Call struct { - *mock.Call -} - -// UpdateProjectInvitationById is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - invitationId string -// - groupInvitationUpdateRequest *admin.GroupInvitationUpdateRequest -func (_e *ProjectsApi_Expecter) UpdateProjectInvitationById(ctx interface{}, groupId interface{}, invitationId interface{}, groupInvitationUpdateRequest interface{}) *ProjectsApi_UpdateProjectInvitationById_Call { - return &ProjectsApi_UpdateProjectInvitationById_Call{Call: _e.mock.On("UpdateProjectInvitationById", ctx, groupId, invitationId, groupInvitationUpdateRequest)} -} - -func (_c *ProjectsApi_UpdateProjectInvitationById_Call) Run(run func(ctx context.Context, groupId string, invitationId string, groupInvitationUpdateRequest *admin.GroupInvitationUpdateRequest)) *ProjectsApi_UpdateProjectInvitationById_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.GroupInvitationUpdateRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationById_Call) Return(_a0 admin.UpdateProjectInvitationByIdApiRequest) *ProjectsApi_UpdateProjectInvitationById_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationById_Call) RunAndReturn(run func(context.Context, string, string, *admin.GroupInvitationUpdateRequest) admin.UpdateProjectInvitationByIdApiRequest) *ProjectsApi_UpdateProjectInvitationById_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitationByIdExecute provides a mock function with given fields: r -func (_m *ProjectsApi) UpdateProjectInvitationByIdExecute(r admin.UpdateProjectInvitationByIdApiRequest) (*admin.GroupInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitationByIdExecute") - } - - var r0 *admin.GroupInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateProjectInvitationByIdApiRequest) (*admin.GroupInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateProjectInvitationByIdApiRequest) *admin.GroupInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateProjectInvitationByIdApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateProjectInvitationByIdApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_UpdateProjectInvitationByIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitationByIdExecute' -type ProjectsApi_UpdateProjectInvitationByIdExecute_Call struct { - *mock.Call -} - -// UpdateProjectInvitationByIdExecute is a helper method to define mock.On call -// - r admin.UpdateProjectInvitationByIdApiRequest -func (_e *ProjectsApi_Expecter) UpdateProjectInvitationByIdExecute(r interface{}) *ProjectsApi_UpdateProjectInvitationByIdExecute_Call { - return &ProjectsApi_UpdateProjectInvitationByIdExecute_Call{Call: _e.mock.On("UpdateProjectInvitationByIdExecute", r)} -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdExecute_Call) Run(run func(r admin.UpdateProjectInvitationByIdApiRequest)) *ProjectsApi_UpdateProjectInvitationByIdExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateProjectInvitationByIdApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdExecute_Call) Return(_a0 *admin.GroupInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_UpdateProjectInvitationByIdExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdExecute_Call) RunAndReturn(run func(admin.UpdateProjectInvitationByIdApiRequest) (*admin.GroupInvitation, *http.Response, error)) *ProjectsApi_UpdateProjectInvitationByIdExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitationByIdWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) UpdateProjectInvitationByIdWithParams(ctx context.Context, args *admin.UpdateProjectInvitationByIdApiParams) admin.UpdateProjectInvitationByIdApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitationByIdWithParams") - } - - var r0 admin.UpdateProjectInvitationByIdApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateProjectInvitationByIdApiParams) admin.UpdateProjectInvitationByIdApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateProjectInvitationByIdApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectInvitationByIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitationByIdWithParams' -type ProjectsApi_UpdateProjectInvitationByIdWithParams_Call struct { - *mock.Call -} - -// UpdateProjectInvitationByIdWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateProjectInvitationByIdApiParams -func (_e *ProjectsApi_Expecter) UpdateProjectInvitationByIdWithParams(ctx interface{}, args interface{}) *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call { - return &ProjectsApi_UpdateProjectInvitationByIdWithParams_Call{Call: _e.mock.On("UpdateProjectInvitationByIdWithParams", ctx, args)} -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateProjectInvitationByIdApiParams)) *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateProjectInvitationByIdApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call) Return(_a0 admin.UpdateProjectInvitationByIdApiRequest) *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateProjectInvitationByIdApiParams) admin.UpdateProjectInvitationByIdApiRequest) *ProjectsApi_UpdateProjectInvitationByIdWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitationExecute provides a mock function with given fields: r -func (_m *ProjectsApi) UpdateProjectInvitationExecute(r admin.UpdateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitationExecute") - } - - var r0 *admin.GroupInvitation - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateProjectInvitationApiRequest) *admin.GroupInvitation); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupInvitation) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateProjectInvitationApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateProjectInvitationApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_UpdateProjectInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitationExecute' -type ProjectsApi_UpdateProjectInvitationExecute_Call struct { - *mock.Call -} - -// UpdateProjectInvitationExecute is a helper method to define mock.On call -// - r admin.UpdateProjectInvitationApiRequest -func (_e *ProjectsApi_Expecter) UpdateProjectInvitationExecute(r interface{}) *ProjectsApi_UpdateProjectInvitationExecute_Call { - return &ProjectsApi_UpdateProjectInvitationExecute_Call{Call: _e.mock.On("UpdateProjectInvitationExecute", r)} -} - -func (_c *ProjectsApi_UpdateProjectInvitationExecute_Call) Run(run func(r admin.UpdateProjectInvitationApiRequest)) *ProjectsApi_UpdateProjectInvitationExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateProjectInvitationApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationExecute_Call) Return(_a0 *admin.GroupInvitation, _a1 *http.Response, _a2 error) *ProjectsApi_UpdateProjectInvitationExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationExecute_Call) RunAndReturn(run func(admin.UpdateProjectInvitationApiRequest) (*admin.GroupInvitation, *http.Response, error)) *ProjectsApi_UpdateProjectInvitationExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectInvitationWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) UpdateProjectInvitationWithParams(ctx context.Context, args *admin.UpdateProjectInvitationApiParams) admin.UpdateProjectInvitationApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectInvitationWithParams") - } - - var r0 admin.UpdateProjectInvitationApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateProjectInvitationApiParams) admin.UpdateProjectInvitationApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateProjectInvitationApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectInvitationWithParams' -type ProjectsApi_UpdateProjectInvitationWithParams_Call struct { - *mock.Call -} - -// UpdateProjectInvitationWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateProjectInvitationApiParams -func (_e *ProjectsApi_Expecter) UpdateProjectInvitationWithParams(ctx interface{}, args interface{}) *ProjectsApi_UpdateProjectInvitationWithParams_Call { - return &ProjectsApi_UpdateProjectInvitationWithParams_Call{Call: _e.mock.On("UpdateProjectInvitationWithParams", ctx, args)} -} - -func (_c *ProjectsApi_UpdateProjectInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateProjectInvitationApiParams)) *ProjectsApi_UpdateProjectInvitationWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateProjectInvitationApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationWithParams_Call) Return(_a0 admin.UpdateProjectInvitationApiRequest) *ProjectsApi_UpdateProjectInvitationWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateProjectInvitationApiParams) admin.UpdateProjectInvitationApiRequest) *ProjectsApi_UpdateProjectInvitationWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectRoles provides a mock function with given fields: ctx, groupId, userId, updateGroupRolesForUser -func (_m *ProjectsApi) UpdateProjectRoles(ctx context.Context, groupId string, userId string, updateGroupRolesForUser *admin.UpdateGroupRolesForUser) admin.UpdateProjectRolesApiRequest { - ret := _m.Called(ctx, groupId, userId, updateGroupRolesForUser) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectRoles") - } - - var r0 admin.UpdateProjectRolesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UpdateGroupRolesForUser) admin.UpdateProjectRolesApiRequest); ok { - r0 = rf(ctx, groupId, userId, updateGroupRolesForUser) - } else { - r0 = ret.Get(0).(admin.UpdateProjectRolesApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectRoles' -type ProjectsApi_UpdateProjectRoles_Call struct { - *mock.Call -} - -// UpdateProjectRoles is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - userId string -// - updateGroupRolesForUser *admin.UpdateGroupRolesForUser -func (_e *ProjectsApi_Expecter) UpdateProjectRoles(ctx interface{}, groupId interface{}, userId interface{}, updateGroupRolesForUser interface{}) *ProjectsApi_UpdateProjectRoles_Call { - return &ProjectsApi_UpdateProjectRoles_Call{Call: _e.mock.On("UpdateProjectRoles", ctx, groupId, userId, updateGroupRolesForUser)} -} - -func (_c *ProjectsApi_UpdateProjectRoles_Call) Run(run func(ctx context.Context, groupId string, userId string, updateGroupRolesForUser *admin.UpdateGroupRolesForUser)) *ProjectsApi_UpdateProjectRoles_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateGroupRolesForUser)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRoles_Call) Return(_a0 admin.UpdateProjectRolesApiRequest) *ProjectsApi_UpdateProjectRoles_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateGroupRolesForUser) admin.UpdateProjectRolesApiRequest) *ProjectsApi_UpdateProjectRoles_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectRolesExecute provides a mock function with given fields: r -func (_m *ProjectsApi) UpdateProjectRolesExecute(r admin.UpdateProjectRolesApiRequest) (*admin.UpdateGroupRolesForUser, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectRolesExecute") - } - - var r0 *admin.UpdateGroupRolesForUser - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateProjectRolesApiRequest) (*admin.UpdateGroupRolesForUser, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateProjectRolesApiRequest) *admin.UpdateGroupRolesForUser); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.UpdateGroupRolesForUser) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateProjectRolesApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateProjectRolesApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_UpdateProjectRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectRolesExecute' -type ProjectsApi_UpdateProjectRolesExecute_Call struct { - *mock.Call -} - -// UpdateProjectRolesExecute is a helper method to define mock.On call -// - r admin.UpdateProjectRolesApiRequest -func (_e *ProjectsApi_Expecter) UpdateProjectRolesExecute(r interface{}) *ProjectsApi_UpdateProjectRolesExecute_Call { - return &ProjectsApi_UpdateProjectRolesExecute_Call{Call: _e.mock.On("UpdateProjectRolesExecute", r)} -} - -func (_c *ProjectsApi_UpdateProjectRolesExecute_Call) Run(run func(r admin.UpdateProjectRolesApiRequest)) *ProjectsApi_UpdateProjectRolesExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateProjectRolesApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRolesExecute_Call) Return(_a0 *admin.UpdateGroupRolesForUser, _a1 *http.Response, _a2 error) *ProjectsApi_UpdateProjectRolesExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRolesExecute_Call) RunAndReturn(run func(admin.UpdateProjectRolesApiRequest) (*admin.UpdateGroupRolesForUser, *http.Response, error)) *ProjectsApi_UpdateProjectRolesExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectRolesWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) UpdateProjectRolesWithParams(ctx context.Context, args *admin.UpdateProjectRolesApiParams) admin.UpdateProjectRolesApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectRolesWithParams") - } - - var r0 admin.UpdateProjectRolesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateProjectRolesApiParams) admin.UpdateProjectRolesApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateProjectRolesApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectRolesWithParams' -type ProjectsApi_UpdateProjectRolesWithParams_Call struct { - *mock.Call -} - -// UpdateProjectRolesWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateProjectRolesApiParams -func (_e *ProjectsApi_Expecter) UpdateProjectRolesWithParams(ctx interface{}, args interface{}) *ProjectsApi_UpdateProjectRolesWithParams_Call { - return &ProjectsApi_UpdateProjectRolesWithParams_Call{Call: _e.mock.On("UpdateProjectRolesWithParams", ctx, args)} -} - -func (_c *ProjectsApi_UpdateProjectRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateProjectRolesApiParams)) *ProjectsApi_UpdateProjectRolesWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateProjectRolesApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRolesWithParams_Call) Return(_a0 admin.UpdateProjectRolesApiRequest) *ProjectsApi_UpdateProjectRolesWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateProjectRolesApiParams) admin.UpdateProjectRolesApiRequest) *ProjectsApi_UpdateProjectRolesWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectSettings provides a mock function with given fields: ctx, groupId, groupSettings -func (_m *ProjectsApi) UpdateProjectSettings(ctx context.Context, groupId string, groupSettings *admin.GroupSettings) admin.UpdateProjectSettingsApiRequest { - ret := _m.Called(ctx, groupId, groupSettings) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectSettings") - } - - var r0 admin.UpdateProjectSettingsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupSettings) admin.UpdateProjectSettingsApiRequest); ok { - r0 = rf(ctx, groupId, groupSettings) - } else { - r0 = ret.Get(0).(admin.UpdateProjectSettingsApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectSettings' -type ProjectsApi_UpdateProjectSettings_Call struct { - *mock.Call -} - -// UpdateProjectSettings is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - groupSettings *admin.GroupSettings -func (_e *ProjectsApi_Expecter) UpdateProjectSettings(ctx interface{}, groupId interface{}, groupSettings interface{}) *ProjectsApi_UpdateProjectSettings_Call { - return &ProjectsApi_UpdateProjectSettings_Call{Call: _e.mock.On("UpdateProjectSettings", ctx, groupId, groupSettings)} -} - -func (_c *ProjectsApi_UpdateProjectSettings_Call) Run(run func(ctx context.Context, groupId string, groupSettings *admin.GroupSettings)) *ProjectsApi_UpdateProjectSettings_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupSettings)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettings_Call) Return(_a0 admin.UpdateProjectSettingsApiRequest) *ProjectsApi_UpdateProjectSettings_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettings_Call) RunAndReturn(run func(context.Context, string, *admin.GroupSettings) admin.UpdateProjectSettingsApiRequest) *ProjectsApi_UpdateProjectSettings_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectSettingsExecute provides a mock function with given fields: r -func (_m *ProjectsApi) UpdateProjectSettingsExecute(r admin.UpdateProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectSettingsExecute") - } - - var r0 *admin.GroupSettings - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateProjectSettingsApiRequest) *admin.GroupSettings); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.GroupSettings) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateProjectSettingsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateProjectSettingsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// ProjectsApi_UpdateProjectSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectSettingsExecute' -type ProjectsApi_UpdateProjectSettingsExecute_Call struct { - *mock.Call -} - -// UpdateProjectSettingsExecute is a helper method to define mock.On call -// - r admin.UpdateProjectSettingsApiRequest -func (_e *ProjectsApi_Expecter) UpdateProjectSettingsExecute(r interface{}) *ProjectsApi_UpdateProjectSettingsExecute_Call { - return &ProjectsApi_UpdateProjectSettingsExecute_Call{Call: _e.mock.On("UpdateProjectSettingsExecute", r)} -} - -func (_c *ProjectsApi_UpdateProjectSettingsExecute_Call) Run(run func(r admin.UpdateProjectSettingsApiRequest)) *ProjectsApi_UpdateProjectSettingsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateProjectSettingsApiRequest)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettingsExecute_Call) Return(_a0 *admin.GroupSettings, _a1 *http.Response, _a2 error) *ProjectsApi_UpdateProjectSettingsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettingsExecute_Call) RunAndReturn(run func(admin.UpdateProjectSettingsApiRequest) (*admin.GroupSettings, *http.Response, error)) *ProjectsApi_UpdateProjectSettingsExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectSettingsWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) UpdateProjectSettingsWithParams(ctx context.Context, args *admin.UpdateProjectSettingsApiParams) admin.UpdateProjectSettingsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectSettingsWithParams") - } - - var r0 admin.UpdateProjectSettingsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateProjectSettingsApiParams) admin.UpdateProjectSettingsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateProjectSettingsApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectSettingsWithParams' -type ProjectsApi_UpdateProjectSettingsWithParams_Call struct { - *mock.Call -} - -// UpdateProjectSettingsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateProjectSettingsApiParams -func (_e *ProjectsApi_Expecter) UpdateProjectSettingsWithParams(ctx interface{}, args interface{}) *ProjectsApi_UpdateProjectSettingsWithParams_Call { - return &ProjectsApi_UpdateProjectSettingsWithParams_Call{Call: _e.mock.On("UpdateProjectSettingsWithParams", ctx, args)} -} - -func (_c *ProjectsApi_UpdateProjectSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateProjectSettingsApiParams)) *ProjectsApi_UpdateProjectSettingsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateProjectSettingsApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettingsWithParams_Call) Return(_a0 admin.UpdateProjectSettingsApiRequest) *ProjectsApi_UpdateProjectSettingsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateProjectSettingsApiParams) admin.UpdateProjectSettingsApiRequest) *ProjectsApi_UpdateProjectSettingsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateProjectWithParams provides a mock function with given fields: ctx, args -func (_m *ProjectsApi) UpdateProjectWithParams(ctx context.Context, args *admin.UpdateProjectApiParams) admin.UpdateProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateProjectWithParams") - } - - var r0 admin.UpdateProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateProjectApiParams) admin.UpdateProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateProjectApiRequest) - } - - return r0 -} - -// ProjectsApi_UpdateProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProjectWithParams' -type ProjectsApi_UpdateProjectWithParams_Call struct { - *mock.Call -} - -// UpdateProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateProjectApiParams -func (_e *ProjectsApi_Expecter) UpdateProjectWithParams(ctx interface{}, args interface{}) *ProjectsApi_UpdateProjectWithParams_Call { - return &ProjectsApi_UpdateProjectWithParams_Call{Call: _e.mock.On("UpdateProjectWithParams", ctx, args)} -} - -func (_c *ProjectsApi_UpdateProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateProjectApiParams)) *ProjectsApi_UpdateProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateProjectApiParams)) - }) - return _c -} - -func (_c *ProjectsApi_UpdateProjectWithParams_Call) Return(_a0 admin.UpdateProjectApiRequest) *ProjectsApi_UpdateProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *ProjectsApi_UpdateProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateProjectApiParams) admin.UpdateProjectApiRequest) *ProjectsApi_UpdateProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// NewProjectsApi creates a new instance of ProjectsApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewProjectsApi(t interface { - mock.TestingT - Cleanup(func()) -}) *ProjectsApi { - mock := &ProjectsApi{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/testutil/mocksvc/teams_api.go b/internal/testutil/mocksvc/teams_api.go deleted file mode 100644 index 71e1f09e84..0000000000 --- a/internal/testutil/mocksvc/teams_api.go +++ /dev/null @@ -1,2130 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocksvc - -import ( - context "context" - - admin "go.mongodb.org/atlas-sdk/v20231115008/admin" - - http "net/http" - - mock "github.com/stretchr/testify/mock" -) - -// TeamsApi is an autogenerated mock type for the TeamsApi type -type TeamsApi struct { - mock.Mock -} - -type TeamsApi_Expecter struct { - mock *mock.Mock -} - -func (_m *TeamsApi) EXPECT() *TeamsApi_Expecter { - return &TeamsApi_Expecter{mock: &_m.Mock} -} - -// AddAllTeamsToProject provides a mock function with given fields: ctx, groupId, teamRole -func (_m *TeamsApi) AddAllTeamsToProject(ctx context.Context, groupId string, teamRole *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest { - ret := _m.Called(ctx, groupId, teamRole) - - if len(ret) == 0 { - panic("no return value specified for AddAllTeamsToProject") - } - - var r0 admin.AddAllTeamsToProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest); ok { - r0 = rf(ctx, groupId, teamRole) - } else { - r0 = ret.Get(0).(admin.AddAllTeamsToProjectApiRequest) - } - - return r0 -} - -// TeamsApi_AddAllTeamsToProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProject' -type TeamsApi_AddAllTeamsToProject_Call struct { - *mock.Call -} - -// AddAllTeamsToProject is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - teamRole *[]admin.TeamRole -func (_e *TeamsApi_Expecter) AddAllTeamsToProject(ctx interface{}, groupId interface{}, teamRole interface{}) *TeamsApi_AddAllTeamsToProject_Call { - return &TeamsApi_AddAllTeamsToProject_Call{Call: _e.mock.On("AddAllTeamsToProject", ctx, groupId, teamRole)} -} - -func (_c *TeamsApi_AddAllTeamsToProject_Call) Run(run func(ctx context.Context, groupId string, teamRole *[]admin.TeamRole)) *TeamsApi_AddAllTeamsToProject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*[]admin.TeamRole)) - }) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProject_Call) Return(_a0 admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProject_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProject_Call) RunAndReturn(run func(context.Context, string, *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProject_Call { - _c.Call.Return(run) - return _c -} - -// AddAllTeamsToProjectExecute provides a mock function with given fields: r -func (_m *TeamsApi) AddAllTeamsToProjectExecute(r admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for AddAllTeamsToProjectExecute") - } - - var r0 *admin.PaginatedTeamRole - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.AddAllTeamsToProjectApiRequest) *admin.PaginatedTeamRole); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedTeamRole) - } - } - - if rf, ok := ret.Get(1).(func(admin.AddAllTeamsToProjectApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.AddAllTeamsToProjectApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_AddAllTeamsToProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProjectExecute' -type TeamsApi_AddAllTeamsToProjectExecute_Call struct { - *mock.Call -} - -// AddAllTeamsToProjectExecute is a helper method to define mock.On call -// - r admin.AddAllTeamsToProjectApiRequest -func (_e *TeamsApi_Expecter) AddAllTeamsToProjectExecute(r interface{}) *TeamsApi_AddAllTeamsToProjectExecute_Call { - return &TeamsApi_AddAllTeamsToProjectExecute_Call{Call: _e.mock.On("AddAllTeamsToProjectExecute", r)} -} - -func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) Run(run func(r admin.AddAllTeamsToProjectApiRequest)) *TeamsApi_AddAllTeamsToProjectExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.AddAllTeamsToProjectApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_AddAllTeamsToProjectExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) RunAndReturn(run func(admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_AddAllTeamsToProjectExecute_Call { - _c.Call.Return(run) - return _c -} - -// AddAllTeamsToProjectWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) AddAllTeamsToProjectWithParams(ctx context.Context, args *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for AddAllTeamsToProjectWithParams") - } - - var r0 admin.AddAllTeamsToProjectApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.AddAllTeamsToProjectApiRequest) - } - - return r0 -} - -// TeamsApi_AddAllTeamsToProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProjectWithParams' -type TeamsApi_AddAllTeamsToProjectWithParams_Call struct { - *mock.Call -} - -// AddAllTeamsToProjectWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.AddAllTeamsToProjectApiParams -func (_e *TeamsApi_Expecter) AddAllTeamsToProjectWithParams(ctx interface{}, args interface{}) *TeamsApi_AddAllTeamsToProjectWithParams_Call { - return &TeamsApi_AddAllTeamsToProjectWithParams_Call{Call: _e.mock.On("AddAllTeamsToProjectWithParams", ctx, args)} -} - -func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.AddAllTeamsToProjectApiParams)) *TeamsApi_AddAllTeamsToProjectWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.AddAllTeamsToProjectApiParams)) - }) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) Return(_a0 admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProjectWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProjectWithParams_Call { - _c.Call.Return(run) - return _c -} - -// AddTeamUser provides a mock function with given fields: ctx, orgId, teamId, addUserToTeam -func (_m *TeamsApi) AddTeamUser(ctx context.Context, orgId string, teamId string, addUserToTeam *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest { - ret := _m.Called(ctx, orgId, teamId, addUserToTeam) - - if len(ret) == 0 { - panic("no return value specified for AddTeamUser") - } - - var r0 admin.AddTeamUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest); ok { - r0 = rf(ctx, orgId, teamId, addUserToTeam) - } else { - r0 = ret.Get(0).(admin.AddTeamUserApiRequest) - } - - return r0 -} - -// TeamsApi_AddTeamUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUser' -type TeamsApi_AddTeamUser_Call struct { - *mock.Call -} - -// AddTeamUser is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -// - addUserToTeam *[]admin.AddUserToTeam -func (_e *TeamsApi_Expecter) AddTeamUser(ctx interface{}, orgId interface{}, teamId interface{}, addUserToTeam interface{}) *TeamsApi_AddTeamUser_Call { - return &TeamsApi_AddTeamUser_Call{Call: _e.mock.On("AddTeamUser", ctx, orgId, teamId, addUserToTeam)} -} - -func (_c *TeamsApi_AddTeamUser_Call) Run(run func(ctx context.Context, orgId string, teamId string, addUserToTeam *[]admin.AddUserToTeam)) *TeamsApi_AddTeamUser_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.AddUserToTeam)) - }) - return _c -} - -func (_c *TeamsApi_AddTeamUser_Call) Return(_a0 admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUser_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_AddTeamUser_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUser_Call { - _c.Call.Return(run) - return _c -} - -// AddTeamUserExecute provides a mock function with given fields: r -func (_m *TeamsApi) AddTeamUserExecute(r admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for AddTeamUserExecute") - } - - var r0 *admin.PaginatedApiAppUser - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.AddTeamUserApiRequest) *admin.PaginatedApiAppUser); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedApiAppUser) - } - } - - if rf, ok := ret.Get(1).(func(admin.AddTeamUserApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.AddTeamUserApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_AddTeamUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUserExecute' -type TeamsApi_AddTeamUserExecute_Call struct { - *mock.Call -} - -// AddTeamUserExecute is a helper method to define mock.On call -// - r admin.AddTeamUserApiRequest -func (_e *TeamsApi_Expecter) AddTeamUserExecute(r interface{}) *TeamsApi_AddTeamUserExecute_Call { - return &TeamsApi_AddTeamUserExecute_Call{Call: _e.mock.On("AddTeamUserExecute", r)} -} - -func (_c *TeamsApi_AddTeamUserExecute_Call) Run(run func(r admin.AddTeamUserApiRequest)) *TeamsApi_AddTeamUserExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.AddTeamUserApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_AddTeamUserExecute_Call) Return(_a0 *admin.PaginatedApiAppUser, _a1 *http.Response, _a2 error) *TeamsApi_AddTeamUserExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_AddTeamUserExecute_Call) RunAndReturn(run func(admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)) *TeamsApi_AddTeamUserExecute_Call { - _c.Call.Return(run) - return _c -} - -// AddTeamUserWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) AddTeamUserWithParams(ctx context.Context, args *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for AddTeamUserWithParams") - } - - var r0 admin.AddTeamUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.AddTeamUserApiRequest) - } - - return r0 -} - -// TeamsApi_AddTeamUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUserWithParams' -type TeamsApi_AddTeamUserWithParams_Call struct { - *mock.Call -} - -// AddTeamUserWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.AddTeamUserApiParams -func (_e *TeamsApi_Expecter) AddTeamUserWithParams(ctx interface{}, args interface{}) *TeamsApi_AddTeamUserWithParams_Call { - return &TeamsApi_AddTeamUserWithParams_Call{Call: _e.mock.On("AddTeamUserWithParams", ctx, args)} -} - -func (_c *TeamsApi_AddTeamUserWithParams_Call) Run(run func(ctx context.Context, args *admin.AddTeamUserApiParams)) *TeamsApi_AddTeamUserWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.AddTeamUserApiParams)) - }) - return _c -} - -func (_c *TeamsApi_AddTeamUserWithParams_Call) Return(_a0 admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUserWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_AddTeamUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUserWithParams_Call { - _c.Call.Return(run) - return _c -} - -// CreateTeam provides a mock function with given fields: ctx, orgId, team -func (_m *TeamsApi) CreateTeam(ctx context.Context, orgId string, team *admin.Team) admin.CreateTeamApiRequest { - ret := _m.Called(ctx, orgId, team) - - if len(ret) == 0 { - panic("no return value specified for CreateTeam") - } - - var r0 admin.CreateTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *admin.Team) admin.CreateTeamApiRequest); ok { - r0 = rf(ctx, orgId, team) - } else { - r0 = ret.Get(0).(admin.CreateTeamApiRequest) - } - - return r0 -} - -// TeamsApi_CreateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeam' -type TeamsApi_CreateTeam_Call struct { - *mock.Call -} - -// CreateTeam is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - team *admin.Team -func (_e *TeamsApi_Expecter) CreateTeam(ctx interface{}, orgId interface{}, team interface{}) *TeamsApi_CreateTeam_Call { - return &TeamsApi_CreateTeam_Call{Call: _e.mock.On("CreateTeam", ctx, orgId, team)} -} - -func (_c *TeamsApi_CreateTeam_Call) Run(run func(ctx context.Context, orgId string, team *admin.Team)) *TeamsApi_CreateTeam_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(*admin.Team)) - }) - return _c -} - -func (_c *TeamsApi_CreateTeam_Call) Return(_a0 admin.CreateTeamApiRequest) *TeamsApi_CreateTeam_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_CreateTeam_Call) RunAndReturn(run func(context.Context, string, *admin.Team) admin.CreateTeamApiRequest) *TeamsApi_CreateTeam_Call { - _c.Call.Return(run) - return _c -} - -// CreateTeamExecute provides a mock function with given fields: r -func (_m *TeamsApi) CreateTeamExecute(r admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for CreateTeamExecute") - } - - var r0 *admin.Team - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.CreateTeamApiRequest) *admin.Team); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.Team) - } - } - - if rf, ok := ret.Get(1).(func(admin.CreateTeamApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.CreateTeamApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_CreateTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamExecute' -type TeamsApi_CreateTeamExecute_Call struct { - *mock.Call -} - -// CreateTeamExecute is a helper method to define mock.On call -// - r admin.CreateTeamApiRequest -func (_e *TeamsApi_Expecter) CreateTeamExecute(r interface{}) *TeamsApi_CreateTeamExecute_Call { - return &TeamsApi_CreateTeamExecute_Call{Call: _e.mock.On("CreateTeamExecute", r)} -} - -func (_c *TeamsApi_CreateTeamExecute_Call) Run(run func(r admin.CreateTeamApiRequest)) *TeamsApi_CreateTeamExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.CreateTeamApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_CreateTeamExecute_Call) Return(_a0 *admin.Team, _a1 *http.Response, _a2 error) *TeamsApi_CreateTeamExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_CreateTeamExecute_Call) RunAndReturn(run func(admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error)) *TeamsApi_CreateTeamExecute_Call { - _c.Call.Return(run) - return _c -} - -// CreateTeamWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) CreateTeamWithParams(ctx context.Context, args *admin.CreateTeamApiParams) admin.CreateTeamApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for CreateTeamWithParams") - } - - var r0 admin.CreateTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateTeamApiParams) admin.CreateTeamApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.CreateTeamApiRequest) - } - - return r0 -} - -// TeamsApi_CreateTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamWithParams' -type TeamsApi_CreateTeamWithParams_Call struct { - *mock.Call -} - -// CreateTeamWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.CreateTeamApiParams -func (_e *TeamsApi_Expecter) CreateTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_CreateTeamWithParams_Call { - return &TeamsApi_CreateTeamWithParams_Call{Call: _e.mock.On("CreateTeamWithParams", ctx, args)} -} - -func (_c *TeamsApi_CreateTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateTeamApiParams)) *TeamsApi_CreateTeamWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.CreateTeamApiParams)) - }) - return _c -} - -func (_c *TeamsApi_CreateTeamWithParams_Call) Return(_a0 admin.CreateTeamApiRequest) *TeamsApi_CreateTeamWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_CreateTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateTeamApiParams) admin.CreateTeamApiRequest) *TeamsApi_CreateTeamWithParams_Call { - _c.Call.Return(run) - return _c -} - -// DeleteTeam provides a mock function with given fields: ctx, orgId, teamId -func (_m *TeamsApi) DeleteTeam(ctx context.Context, orgId string, teamId string) admin.DeleteTeamApiRequest { - ret := _m.Called(ctx, orgId, teamId) - - if len(ret) == 0 { - panic("no return value specified for DeleteTeam") - } - - var r0 admin.DeleteTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteTeamApiRequest); ok { - r0 = rf(ctx, orgId, teamId) - } else { - r0 = ret.Get(0).(admin.DeleteTeamApiRequest) - } - - return r0 -} - -// TeamsApi_DeleteTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeam' -type TeamsApi_DeleteTeam_Call struct { - *mock.Call -} - -// DeleteTeam is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -func (_e *TeamsApi_Expecter) DeleteTeam(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_DeleteTeam_Call { - return &TeamsApi_DeleteTeam_Call{Call: _e.mock.On("DeleteTeam", ctx, orgId, teamId)} -} - -func (_c *TeamsApi_DeleteTeam_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_DeleteTeam_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *TeamsApi_DeleteTeam_Call) Return(_a0 admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeam_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_DeleteTeam_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeam_Call { - _c.Call.Return(run) - return _c -} - -// DeleteTeamExecute provides a mock function with given fields: r -func (_m *TeamsApi) DeleteTeamExecute(r admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for DeleteTeamExecute") - } - - var r0 map[string]interface{} - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.DeleteTeamApiRequest) map[string]interface{}); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(map[string]interface{}) - } - } - - if rf, ok := ret.Get(1).(func(admin.DeleteTeamApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.DeleteTeamApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_DeleteTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeamExecute' -type TeamsApi_DeleteTeamExecute_Call struct { - *mock.Call -} - -// DeleteTeamExecute is a helper method to define mock.On call -// - r admin.DeleteTeamApiRequest -func (_e *TeamsApi_Expecter) DeleteTeamExecute(r interface{}) *TeamsApi_DeleteTeamExecute_Call { - return &TeamsApi_DeleteTeamExecute_Call{Call: _e.mock.On("DeleteTeamExecute", r)} -} - -func (_c *TeamsApi_DeleteTeamExecute_Call) Run(run func(r admin.DeleteTeamApiRequest)) *TeamsApi_DeleteTeamExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.DeleteTeamApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_DeleteTeamExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *TeamsApi_DeleteTeamExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_DeleteTeamExecute_Call) RunAndReturn(run func(admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error)) *TeamsApi_DeleteTeamExecute_Call { - _c.Call.Return(run) - return _c -} - -// DeleteTeamWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) DeleteTeamWithParams(ctx context.Context, args *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for DeleteTeamWithParams") - } - - var r0 admin.DeleteTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.DeleteTeamApiRequest) - } - - return r0 -} - -// TeamsApi_DeleteTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeamWithParams' -type TeamsApi_DeleteTeamWithParams_Call struct { - *mock.Call -} - -// DeleteTeamWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.DeleteTeamApiParams -func (_e *TeamsApi_Expecter) DeleteTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_DeleteTeamWithParams_Call { - return &TeamsApi_DeleteTeamWithParams_Call{Call: _e.mock.On("DeleteTeamWithParams", ctx, args)} -} - -func (_c *TeamsApi_DeleteTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteTeamApiParams)) *TeamsApi_DeleteTeamWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.DeleteTeamApiParams)) - }) - return _c -} - -func (_c *TeamsApi_DeleteTeamWithParams_Call) Return(_a0 admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeamWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_DeleteTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeamWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamById provides a mock function with given fields: ctx, orgId, teamId -func (_m *TeamsApi) GetTeamById(ctx context.Context, orgId string, teamId string) admin.GetTeamByIdApiRequest { - ret := _m.Called(ctx, orgId, teamId) - - if len(ret) == 0 { - panic("no return value specified for GetTeamById") - } - - var r0 admin.GetTeamByIdApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetTeamByIdApiRequest); ok { - r0 = rf(ctx, orgId, teamId) - } else { - r0 = ret.Get(0).(admin.GetTeamByIdApiRequest) - } - - return r0 -} - -// TeamsApi_GetTeamById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamById' -type TeamsApi_GetTeamById_Call struct { - *mock.Call -} - -// GetTeamById is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -func (_e *TeamsApi_Expecter) GetTeamById(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_GetTeamById_Call { - return &TeamsApi_GetTeamById_Call{Call: _e.mock.On("GetTeamById", ctx, orgId, teamId)} -} - -func (_c *TeamsApi_GetTeamById_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_GetTeamById_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamById_Call) Return(_a0 admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamById_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_GetTeamById_Call) RunAndReturn(run func(context.Context, string, string) admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamById_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamByIdExecute provides a mock function with given fields: r -func (_m *TeamsApi) GetTeamByIdExecute(r admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetTeamByIdExecute") - } - - var r0 *admin.TeamResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetTeamByIdApiRequest) *admin.TeamResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.TeamResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetTeamByIdApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetTeamByIdApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_GetTeamByIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByIdExecute' -type TeamsApi_GetTeamByIdExecute_Call struct { - *mock.Call -} - -// GetTeamByIdExecute is a helper method to define mock.On call -// - r admin.GetTeamByIdApiRequest -func (_e *TeamsApi_Expecter) GetTeamByIdExecute(r interface{}) *TeamsApi_GetTeamByIdExecute_Call { - return &TeamsApi_GetTeamByIdExecute_Call{Call: _e.mock.On("GetTeamByIdExecute", r)} -} - -func (_c *TeamsApi_GetTeamByIdExecute_Call) Run(run func(r admin.GetTeamByIdApiRequest)) *TeamsApi_GetTeamByIdExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetTeamByIdApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamByIdExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_GetTeamByIdExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_GetTeamByIdExecute_Call) RunAndReturn(run func(admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_GetTeamByIdExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamByIdWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) GetTeamByIdWithParams(ctx context.Context, args *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetTeamByIdWithParams") - } - - var r0 admin.GetTeamByIdApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetTeamByIdApiRequest) - } - - return r0 -} - -// TeamsApi_GetTeamByIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByIdWithParams' -type TeamsApi_GetTeamByIdWithParams_Call struct { - *mock.Call -} - -// GetTeamByIdWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetTeamByIdApiParams -func (_e *TeamsApi_Expecter) GetTeamByIdWithParams(ctx interface{}, args interface{}) *TeamsApi_GetTeamByIdWithParams_Call { - return &TeamsApi_GetTeamByIdWithParams_Call{Call: _e.mock.On("GetTeamByIdWithParams", ctx, args)} -} - -func (_c *TeamsApi_GetTeamByIdWithParams_Call) Run(run func(ctx context.Context, args *admin.GetTeamByIdApiParams)) *TeamsApi_GetTeamByIdWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetTeamByIdApiParams)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamByIdWithParams_Call) Return(_a0 admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamByIdWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_GetTeamByIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamByIdWithParams_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamByName provides a mock function with given fields: ctx, orgId, teamName -func (_m *TeamsApi) GetTeamByName(ctx context.Context, orgId string, teamName string) admin.GetTeamByNameApiRequest { - ret := _m.Called(ctx, orgId, teamName) - - if len(ret) == 0 { - panic("no return value specified for GetTeamByName") - } - - var r0 admin.GetTeamByNameApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetTeamByNameApiRequest); ok { - r0 = rf(ctx, orgId, teamName) - } else { - r0 = ret.Get(0).(admin.GetTeamByNameApiRequest) - } - - return r0 -} - -// TeamsApi_GetTeamByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByName' -type TeamsApi_GetTeamByName_Call struct { - *mock.Call -} - -// GetTeamByName is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamName string -func (_e *TeamsApi_Expecter) GetTeamByName(ctx interface{}, orgId interface{}, teamName interface{}) *TeamsApi_GetTeamByName_Call { - return &TeamsApi_GetTeamByName_Call{Call: _e.mock.On("GetTeamByName", ctx, orgId, teamName)} -} - -func (_c *TeamsApi_GetTeamByName_Call) Run(run func(ctx context.Context, orgId string, teamName string)) *TeamsApi_GetTeamByName_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamByName_Call) Return(_a0 admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByName_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_GetTeamByName_Call) RunAndReturn(run func(context.Context, string, string) admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByName_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamByNameExecute provides a mock function with given fields: r -func (_m *TeamsApi) GetTeamByNameExecute(r admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for GetTeamByNameExecute") - } - - var r0 *admin.TeamResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.GetTeamByNameApiRequest) *admin.TeamResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.TeamResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.GetTeamByNameApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.GetTeamByNameApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_GetTeamByNameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByNameExecute' -type TeamsApi_GetTeamByNameExecute_Call struct { - *mock.Call -} - -// GetTeamByNameExecute is a helper method to define mock.On call -// - r admin.GetTeamByNameApiRequest -func (_e *TeamsApi_Expecter) GetTeamByNameExecute(r interface{}) *TeamsApi_GetTeamByNameExecute_Call { - return &TeamsApi_GetTeamByNameExecute_Call{Call: _e.mock.On("GetTeamByNameExecute", r)} -} - -func (_c *TeamsApi_GetTeamByNameExecute_Call) Run(run func(r admin.GetTeamByNameApiRequest)) *TeamsApi_GetTeamByNameExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.GetTeamByNameApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamByNameExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_GetTeamByNameExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_GetTeamByNameExecute_Call) RunAndReturn(run func(admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_GetTeamByNameExecute_Call { - _c.Call.Return(run) - return _c -} - -// GetTeamByNameWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) GetTeamByNameWithParams(ctx context.Context, args *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for GetTeamByNameWithParams") - } - - var r0 admin.GetTeamByNameApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.GetTeamByNameApiRequest) - } - - return r0 -} - -// TeamsApi_GetTeamByNameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByNameWithParams' -type TeamsApi_GetTeamByNameWithParams_Call struct { - *mock.Call -} - -// GetTeamByNameWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.GetTeamByNameApiParams -func (_e *TeamsApi_Expecter) GetTeamByNameWithParams(ctx interface{}, args interface{}) *TeamsApi_GetTeamByNameWithParams_Call { - return &TeamsApi_GetTeamByNameWithParams_Call{Call: _e.mock.On("GetTeamByNameWithParams", ctx, args)} -} - -func (_c *TeamsApi_GetTeamByNameWithParams_Call) Run(run func(ctx context.Context, args *admin.GetTeamByNameApiParams)) *TeamsApi_GetTeamByNameWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.GetTeamByNameApiParams)) - }) - return _c -} - -func (_c *TeamsApi_GetTeamByNameWithParams_Call) Return(_a0 admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByNameWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_GetTeamByNameWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByNameWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListOrganizationTeams provides a mock function with given fields: ctx, orgId -func (_m *TeamsApi) ListOrganizationTeams(ctx context.Context, orgId string) admin.ListOrganizationTeamsApiRequest { - ret := _m.Called(ctx, orgId) - - if len(ret) == 0 { - panic("no return value specified for ListOrganizationTeams") - } - - var r0 admin.ListOrganizationTeamsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationTeamsApiRequest); ok { - r0 = rf(ctx, orgId) - } else { - r0 = ret.Get(0).(admin.ListOrganizationTeamsApiRequest) - } - - return r0 -} - -// TeamsApi_ListOrganizationTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeams' -type TeamsApi_ListOrganizationTeams_Call struct { - *mock.Call -} - -// ListOrganizationTeams is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -func (_e *TeamsApi_Expecter) ListOrganizationTeams(ctx interface{}, orgId interface{}) *TeamsApi_ListOrganizationTeams_Call { - return &TeamsApi_ListOrganizationTeams_Call{Call: _e.mock.On("ListOrganizationTeams", ctx, orgId)} -} - -func (_c *TeamsApi_ListOrganizationTeams_Call) Run(run func(ctx context.Context, orgId string)) *TeamsApi_ListOrganizationTeams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeams_Call) Return(_a0 admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeams_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeams_Call { - _c.Call.Return(run) - return _c -} - -// ListOrganizationTeamsExecute provides a mock function with given fields: r -func (_m *TeamsApi) ListOrganizationTeamsExecute(r admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListOrganizationTeamsExecute") - } - - var r0 *admin.PaginatedTeam - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListOrganizationTeamsApiRequest) *admin.PaginatedTeam); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedTeam) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListOrganizationTeamsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListOrganizationTeamsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_ListOrganizationTeamsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeamsExecute' -type TeamsApi_ListOrganizationTeamsExecute_Call struct { - *mock.Call -} - -// ListOrganizationTeamsExecute is a helper method to define mock.On call -// - r admin.ListOrganizationTeamsApiRequest -func (_e *TeamsApi_Expecter) ListOrganizationTeamsExecute(r interface{}) *TeamsApi_ListOrganizationTeamsExecute_Call { - return &TeamsApi_ListOrganizationTeamsExecute_Call{Call: _e.mock.On("ListOrganizationTeamsExecute", r)} -} - -func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) Run(run func(r admin.ListOrganizationTeamsApiRequest)) *TeamsApi_ListOrganizationTeamsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListOrganizationTeamsApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) Return(_a0 *admin.PaginatedTeam, _a1 *http.Response, _a2 error) *TeamsApi_ListOrganizationTeamsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) RunAndReturn(run func(admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error)) *TeamsApi_ListOrganizationTeamsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListOrganizationTeamsWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) ListOrganizationTeamsWithParams(ctx context.Context, args *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListOrganizationTeamsWithParams") - } - - var r0 admin.ListOrganizationTeamsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListOrganizationTeamsApiRequest) - } - - return r0 -} - -// TeamsApi_ListOrganizationTeamsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeamsWithParams' -type TeamsApi_ListOrganizationTeamsWithParams_Call struct { - *mock.Call -} - -// ListOrganizationTeamsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListOrganizationTeamsApiParams -func (_e *TeamsApi_Expecter) ListOrganizationTeamsWithParams(ctx interface{}, args interface{}) *TeamsApi_ListOrganizationTeamsWithParams_Call { - return &TeamsApi_ListOrganizationTeamsWithParams_Call{Call: _e.mock.On("ListOrganizationTeamsWithParams", ctx, args)} -} - -func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationTeamsApiParams)) *TeamsApi_ListOrganizationTeamsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListOrganizationTeamsApiParams)) - }) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) Return(_a0 admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeamsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeamsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectTeams provides a mock function with given fields: ctx, groupId -func (_m *TeamsApi) ListProjectTeams(ctx context.Context, groupId string) admin.ListProjectTeamsApiRequest { - ret := _m.Called(ctx, groupId) - - if len(ret) == 0 { - panic("no return value specified for ListProjectTeams") - } - - var r0 admin.ListProjectTeamsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectTeamsApiRequest); ok { - r0 = rf(ctx, groupId) - } else { - r0 = ret.Get(0).(admin.ListProjectTeamsApiRequest) - } - - return r0 -} - -// TeamsApi_ListProjectTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeams' -type TeamsApi_ListProjectTeams_Call struct { - *mock.Call -} - -// ListProjectTeams is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -func (_e *TeamsApi_Expecter) ListProjectTeams(ctx interface{}, groupId interface{}) *TeamsApi_ListProjectTeams_Call { - return &TeamsApi_ListProjectTeams_Call{Call: _e.mock.On("ListProjectTeams", ctx, groupId)} -} - -func (_c *TeamsApi_ListProjectTeams_Call) Run(run func(ctx context.Context, groupId string)) *TeamsApi_ListProjectTeams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *TeamsApi_ListProjectTeams_Call) Return(_a0 admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListProjectTeams_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeams_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectTeamsExecute provides a mock function with given fields: r -func (_m *TeamsApi) ListProjectTeamsExecute(r admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListProjectTeamsExecute") - } - - var r0 *admin.PaginatedTeamRole - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListProjectTeamsApiRequest) *admin.PaginatedTeamRole); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedTeamRole) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListProjectTeamsApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListProjectTeamsApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_ListProjectTeamsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeamsExecute' -type TeamsApi_ListProjectTeamsExecute_Call struct { - *mock.Call -} - -// ListProjectTeamsExecute is a helper method to define mock.On call -// - r admin.ListProjectTeamsApiRequest -func (_e *TeamsApi_Expecter) ListProjectTeamsExecute(r interface{}) *TeamsApi_ListProjectTeamsExecute_Call { - return &TeamsApi_ListProjectTeamsExecute_Call{Call: _e.mock.On("ListProjectTeamsExecute", r)} -} - -func (_c *TeamsApi_ListProjectTeamsExecute_Call) Run(run func(r admin.ListProjectTeamsApiRequest)) *TeamsApi_ListProjectTeamsExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListProjectTeamsApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_ListProjectTeamsExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_ListProjectTeamsExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_ListProjectTeamsExecute_Call) RunAndReturn(run func(admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_ListProjectTeamsExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListProjectTeamsWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) ListProjectTeamsWithParams(ctx context.Context, args *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListProjectTeamsWithParams") - } - - var r0 admin.ListProjectTeamsApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListProjectTeamsApiRequest) - } - - return r0 -} - -// TeamsApi_ListProjectTeamsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeamsWithParams' -type TeamsApi_ListProjectTeamsWithParams_Call struct { - *mock.Call -} - -// ListProjectTeamsWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListProjectTeamsApiParams -func (_e *TeamsApi_Expecter) ListProjectTeamsWithParams(ctx interface{}, args interface{}) *TeamsApi_ListProjectTeamsWithParams_Call { - return &TeamsApi_ListProjectTeamsWithParams_Call{Call: _e.mock.On("ListProjectTeamsWithParams", ctx, args)} -} - -func (_c *TeamsApi_ListProjectTeamsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectTeamsApiParams)) *TeamsApi_ListProjectTeamsWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListProjectTeamsApiParams)) - }) - return _c -} - -func (_c *TeamsApi_ListProjectTeamsWithParams_Call) Return(_a0 admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeamsWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListProjectTeamsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeamsWithParams_Call { - _c.Call.Return(run) - return _c -} - -// ListTeamUsers provides a mock function with given fields: ctx, orgId, teamId -func (_m *TeamsApi) ListTeamUsers(ctx context.Context, orgId string, teamId string) admin.ListTeamUsersApiRequest { - ret := _m.Called(ctx, orgId, teamId) - - if len(ret) == 0 { - panic("no return value specified for ListTeamUsers") - } - - var r0 admin.ListTeamUsersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListTeamUsersApiRequest); ok { - r0 = rf(ctx, orgId, teamId) - } else { - r0 = ret.Get(0).(admin.ListTeamUsersApiRequest) - } - - return r0 -} - -// TeamsApi_ListTeamUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsers' -type TeamsApi_ListTeamUsers_Call struct { - *mock.Call -} - -// ListTeamUsers is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -func (_e *TeamsApi_Expecter) ListTeamUsers(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_ListTeamUsers_Call { - return &TeamsApi_ListTeamUsers_Call{Call: _e.mock.On("ListTeamUsers", ctx, orgId, teamId)} -} - -func (_c *TeamsApi_ListTeamUsers_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_ListTeamUsers_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *TeamsApi_ListTeamUsers_Call) Return(_a0 admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsers_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListTeamUsers_Call) RunAndReturn(run func(context.Context, string, string) admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsers_Call { - _c.Call.Return(run) - return _c -} - -// ListTeamUsersExecute provides a mock function with given fields: r -func (_m *TeamsApi) ListTeamUsersExecute(r admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for ListTeamUsersExecute") - } - - var r0 *admin.PaginatedApiAppUser - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.ListTeamUsersApiRequest) *admin.PaginatedApiAppUser); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedApiAppUser) - } - } - - if rf, ok := ret.Get(1).(func(admin.ListTeamUsersApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.ListTeamUsersApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_ListTeamUsersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsersExecute' -type TeamsApi_ListTeamUsersExecute_Call struct { - *mock.Call -} - -// ListTeamUsersExecute is a helper method to define mock.On call -// - r admin.ListTeamUsersApiRequest -func (_e *TeamsApi_Expecter) ListTeamUsersExecute(r interface{}) *TeamsApi_ListTeamUsersExecute_Call { - return &TeamsApi_ListTeamUsersExecute_Call{Call: _e.mock.On("ListTeamUsersExecute", r)} -} - -func (_c *TeamsApi_ListTeamUsersExecute_Call) Run(run func(r admin.ListTeamUsersApiRequest)) *TeamsApi_ListTeamUsersExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.ListTeamUsersApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_ListTeamUsersExecute_Call) Return(_a0 *admin.PaginatedApiAppUser, _a1 *http.Response, _a2 error) *TeamsApi_ListTeamUsersExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_ListTeamUsersExecute_Call) RunAndReturn(run func(admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)) *TeamsApi_ListTeamUsersExecute_Call { - _c.Call.Return(run) - return _c -} - -// ListTeamUsersWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) ListTeamUsersWithParams(ctx context.Context, args *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for ListTeamUsersWithParams") - } - - var r0 admin.ListTeamUsersApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.ListTeamUsersApiRequest) - } - - return r0 -} - -// TeamsApi_ListTeamUsersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsersWithParams' -type TeamsApi_ListTeamUsersWithParams_Call struct { - *mock.Call -} - -// ListTeamUsersWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.ListTeamUsersApiParams -func (_e *TeamsApi_Expecter) ListTeamUsersWithParams(ctx interface{}, args interface{}) *TeamsApi_ListTeamUsersWithParams_Call { - return &TeamsApi_ListTeamUsersWithParams_Call{Call: _e.mock.On("ListTeamUsersWithParams", ctx, args)} -} - -func (_c *TeamsApi_ListTeamUsersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListTeamUsersApiParams)) *TeamsApi_ListTeamUsersWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.ListTeamUsersApiParams)) - }) - return _c -} - -func (_c *TeamsApi_ListTeamUsersWithParams_Call) Return(_a0 admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsersWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_ListTeamUsersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsersWithParams_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectTeam provides a mock function with given fields: ctx, groupId, teamId -func (_m *TeamsApi) RemoveProjectTeam(ctx context.Context, groupId string, teamId string) admin.RemoveProjectTeamApiRequest { - ret := _m.Called(ctx, groupId, teamId) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectTeam") - } - - var r0 admin.RemoveProjectTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveProjectTeamApiRequest); ok { - r0 = rf(ctx, groupId, teamId) - } else { - r0 = ret.Get(0).(admin.RemoveProjectTeamApiRequest) - } - - return r0 -} - -// TeamsApi_RemoveProjectTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeam' -type TeamsApi_RemoveProjectTeam_Call struct { - *mock.Call -} - -// RemoveProjectTeam is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - teamId string -func (_e *TeamsApi_Expecter) RemoveProjectTeam(ctx interface{}, groupId interface{}, teamId interface{}) *TeamsApi_RemoveProjectTeam_Call { - return &TeamsApi_RemoveProjectTeam_Call{Call: _e.mock.On("RemoveProjectTeam", ctx, groupId, teamId)} -} - -func (_c *TeamsApi_RemoveProjectTeam_Call) Run(run func(ctx context.Context, groupId string, teamId string)) *TeamsApi_RemoveProjectTeam_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string)) - }) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeam_Call) Return(_a0 admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeam_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeam_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeam_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectTeamExecute provides a mock function with given fields: r -func (_m *TeamsApi) RemoveProjectTeamExecute(r admin.RemoveProjectTeamApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectTeamExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.RemoveProjectTeamApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.RemoveProjectTeamApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.RemoveProjectTeamApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TeamsApi_RemoveProjectTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeamExecute' -type TeamsApi_RemoveProjectTeamExecute_Call struct { - *mock.Call -} - -// RemoveProjectTeamExecute is a helper method to define mock.On call -// - r admin.RemoveProjectTeamApiRequest -func (_e *TeamsApi_Expecter) RemoveProjectTeamExecute(r interface{}) *TeamsApi_RemoveProjectTeamExecute_Call { - return &TeamsApi_RemoveProjectTeamExecute_Call{Call: _e.mock.On("RemoveProjectTeamExecute", r)} -} - -func (_c *TeamsApi_RemoveProjectTeamExecute_Call) Run(run func(r admin.RemoveProjectTeamApiRequest)) *TeamsApi_RemoveProjectTeamExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.RemoveProjectTeamApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeamExecute_Call) Return(_a0 *http.Response, _a1 error) *TeamsApi_RemoveProjectTeamExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeamExecute_Call) RunAndReturn(run func(admin.RemoveProjectTeamApiRequest) (*http.Response, error)) *TeamsApi_RemoveProjectTeamExecute_Call { - _c.Call.Return(run) - return _c -} - -// RemoveProjectTeamWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) RemoveProjectTeamWithParams(ctx context.Context, args *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for RemoveProjectTeamWithParams") - } - - var r0 admin.RemoveProjectTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.RemoveProjectTeamApiRequest) - } - - return r0 -} - -// TeamsApi_RemoveProjectTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeamWithParams' -type TeamsApi_RemoveProjectTeamWithParams_Call struct { - *mock.Call -} - -// RemoveProjectTeamWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.RemoveProjectTeamApiParams -func (_e *TeamsApi_Expecter) RemoveProjectTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_RemoveProjectTeamWithParams_Call { - return &TeamsApi_RemoveProjectTeamWithParams_Call{Call: _e.mock.On("RemoveProjectTeamWithParams", ctx, args)} -} - -func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveProjectTeamApiParams)) *TeamsApi_RemoveProjectTeamWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.RemoveProjectTeamApiParams)) - }) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) Return(_a0 admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeamWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeamWithParams_Call { - _c.Call.Return(run) - return _c -} - -// RemoveTeamUser provides a mock function with given fields: ctx, orgId, teamId, userId -func (_m *TeamsApi) RemoveTeamUser(ctx context.Context, orgId string, teamId string, userId string) admin.RemoveTeamUserApiRequest { - ret := _m.Called(ctx, orgId, teamId, userId) - - if len(ret) == 0 { - panic("no return value specified for RemoveTeamUser") - } - - var r0 admin.RemoveTeamUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.RemoveTeamUserApiRequest); ok { - r0 = rf(ctx, orgId, teamId, userId) - } else { - r0 = ret.Get(0).(admin.RemoveTeamUserApiRequest) - } - - return r0 -} - -// TeamsApi_RemoveTeamUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUser' -type TeamsApi_RemoveTeamUser_Call struct { - *mock.Call -} - -// RemoveTeamUser is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -// - userId string -func (_e *TeamsApi_Expecter) RemoveTeamUser(ctx interface{}, orgId interface{}, teamId interface{}, userId interface{}) *TeamsApi_RemoveTeamUser_Call { - return &TeamsApi_RemoveTeamUser_Call{Call: _e.mock.On("RemoveTeamUser", ctx, orgId, teamId, userId)} -} - -func (_c *TeamsApi_RemoveTeamUser_Call) Run(run func(ctx context.Context, orgId string, teamId string, userId string)) *TeamsApi_RemoveTeamUser_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) - }) - return _c -} - -func (_c *TeamsApi_RemoveTeamUser_Call) Return(_a0 admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUser_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RemoveTeamUser_Call) RunAndReturn(run func(context.Context, string, string, string) admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUser_Call { - _c.Call.Return(run) - return _c -} - -// RemoveTeamUserExecute provides a mock function with given fields: r -func (_m *TeamsApi) RemoveTeamUserExecute(r admin.RemoveTeamUserApiRequest) (*http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for RemoveTeamUserExecute") - } - - var r0 *http.Response - var r1 error - if rf, ok := ret.Get(0).(func(admin.RemoveTeamUserApiRequest) (*http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.RemoveTeamUserApiRequest) *http.Response); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*http.Response) - } - } - - if rf, ok := ret.Get(1).(func(admin.RemoveTeamUserApiRequest) error); ok { - r1 = rf(r) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TeamsApi_RemoveTeamUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUserExecute' -type TeamsApi_RemoveTeamUserExecute_Call struct { - *mock.Call -} - -// RemoveTeamUserExecute is a helper method to define mock.On call -// - r admin.RemoveTeamUserApiRequest -func (_e *TeamsApi_Expecter) RemoveTeamUserExecute(r interface{}) *TeamsApi_RemoveTeamUserExecute_Call { - return &TeamsApi_RemoveTeamUserExecute_Call{Call: _e.mock.On("RemoveTeamUserExecute", r)} -} - -func (_c *TeamsApi_RemoveTeamUserExecute_Call) Run(run func(r admin.RemoveTeamUserApiRequest)) *TeamsApi_RemoveTeamUserExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.RemoveTeamUserApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_RemoveTeamUserExecute_Call) Return(_a0 *http.Response, _a1 error) *TeamsApi_RemoveTeamUserExecute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TeamsApi_RemoveTeamUserExecute_Call) RunAndReturn(run func(admin.RemoveTeamUserApiRequest) (*http.Response, error)) *TeamsApi_RemoveTeamUserExecute_Call { - _c.Call.Return(run) - return _c -} - -// RemoveTeamUserWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) RemoveTeamUserWithParams(ctx context.Context, args *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for RemoveTeamUserWithParams") - } - - var r0 admin.RemoveTeamUserApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.RemoveTeamUserApiRequest) - } - - return r0 -} - -// TeamsApi_RemoveTeamUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUserWithParams' -type TeamsApi_RemoveTeamUserWithParams_Call struct { - *mock.Call -} - -// RemoveTeamUserWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.RemoveTeamUserApiParams -func (_e *TeamsApi_Expecter) RemoveTeamUserWithParams(ctx interface{}, args interface{}) *TeamsApi_RemoveTeamUserWithParams_Call { - return &TeamsApi_RemoveTeamUserWithParams_Call{Call: _e.mock.On("RemoveTeamUserWithParams", ctx, args)} -} - -func (_c *TeamsApi_RemoveTeamUserWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveTeamUserApiParams)) *TeamsApi_RemoveTeamUserWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.RemoveTeamUserApiParams)) - }) - return _c -} - -func (_c *TeamsApi_RemoveTeamUserWithParams_Call) Return(_a0 admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUserWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RemoveTeamUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUserWithParams_Call { - _c.Call.Return(run) - return _c -} - -// RenameTeam provides a mock function with given fields: ctx, orgId, teamId, teamUpdate -func (_m *TeamsApi) RenameTeam(ctx context.Context, orgId string, teamId string, teamUpdate *admin.TeamUpdate) admin.RenameTeamApiRequest { - ret := _m.Called(ctx, orgId, teamId, teamUpdate) - - if len(ret) == 0 { - panic("no return value specified for RenameTeam") - } - - var r0 admin.RenameTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TeamUpdate) admin.RenameTeamApiRequest); ok { - r0 = rf(ctx, orgId, teamId, teamUpdate) - } else { - r0 = ret.Get(0).(admin.RenameTeamApiRequest) - } - - return r0 -} - -// TeamsApi_RenameTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeam' -type TeamsApi_RenameTeam_Call struct { - *mock.Call -} - -// RenameTeam is a helper method to define mock.On call -// - ctx context.Context -// - orgId string -// - teamId string -// - teamUpdate *admin.TeamUpdate -func (_e *TeamsApi_Expecter) RenameTeam(ctx interface{}, orgId interface{}, teamId interface{}, teamUpdate interface{}) *TeamsApi_RenameTeam_Call { - return &TeamsApi_RenameTeam_Call{Call: _e.mock.On("RenameTeam", ctx, orgId, teamId, teamUpdate)} -} - -func (_c *TeamsApi_RenameTeam_Call) Run(run func(ctx context.Context, orgId string, teamId string, teamUpdate *admin.TeamUpdate)) *TeamsApi_RenameTeam_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TeamUpdate)) - }) - return _c -} - -func (_c *TeamsApi_RenameTeam_Call) Return(_a0 admin.RenameTeamApiRequest) *TeamsApi_RenameTeam_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RenameTeam_Call) RunAndReturn(run func(context.Context, string, string, *admin.TeamUpdate) admin.RenameTeamApiRequest) *TeamsApi_RenameTeam_Call { - _c.Call.Return(run) - return _c -} - -// RenameTeamExecute provides a mock function with given fields: r -func (_m *TeamsApi) RenameTeamExecute(r admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for RenameTeamExecute") - } - - var r0 *admin.TeamResponse - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.RenameTeamApiRequest) *admin.TeamResponse); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.TeamResponse) - } - } - - if rf, ok := ret.Get(1).(func(admin.RenameTeamApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.RenameTeamApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_RenameTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeamExecute' -type TeamsApi_RenameTeamExecute_Call struct { - *mock.Call -} - -// RenameTeamExecute is a helper method to define mock.On call -// - r admin.RenameTeamApiRequest -func (_e *TeamsApi_Expecter) RenameTeamExecute(r interface{}) *TeamsApi_RenameTeamExecute_Call { - return &TeamsApi_RenameTeamExecute_Call{Call: _e.mock.On("RenameTeamExecute", r)} -} - -func (_c *TeamsApi_RenameTeamExecute_Call) Run(run func(r admin.RenameTeamApiRequest)) *TeamsApi_RenameTeamExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.RenameTeamApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_RenameTeamExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_RenameTeamExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_RenameTeamExecute_Call) RunAndReturn(run func(admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_RenameTeamExecute_Call { - _c.Call.Return(run) - return _c -} - -// RenameTeamWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) RenameTeamWithParams(ctx context.Context, args *admin.RenameTeamApiParams) admin.RenameTeamApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for RenameTeamWithParams") - } - - var r0 admin.RenameTeamApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.RenameTeamApiParams) admin.RenameTeamApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.RenameTeamApiRequest) - } - - return r0 -} - -// TeamsApi_RenameTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeamWithParams' -type TeamsApi_RenameTeamWithParams_Call struct { - *mock.Call -} - -// RenameTeamWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.RenameTeamApiParams -func (_e *TeamsApi_Expecter) RenameTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_RenameTeamWithParams_Call { - return &TeamsApi_RenameTeamWithParams_Call{Call: _e.mock.On("RenameTeamWithParams", ctx, args)} -} - -func (_c *TeamsApi_RenameTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.RenameTeamApiParams)) *TeamsApi_RenameTeamWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.RenameTeamApiParams)) - }) - return _c -} - -func (_c *TeamsApi_RenameTeamWithParams_Call) Return(_a0 admin.RenameTeamApiRequest) *TeamsApi_RenameTeamWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_RenameTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.RenameTeamApiParams) admin.RenameTeamApiRequest) *TeamsApi_RenameTeamWithParams_Call { - _c.Call.Return(run) - return _c -} - -// UpdateTeamRoles provides a mock function with given fields: ctx, groupId, teamId, teamRole -func (_m *TeamsApi) UpdateTeamRoles(ctx context.Context, groupId string, teamId string, teamRole *admin.TeamRole) admin.UpdateTeamRolesApiRequest { - ret := _m.Called(ctx, groupId, teamId, teamRole) - - if len(ret) == 0 { - panic("no return value specified for UpdateTeamRoles") - } - - var r0 admin.UpdateTeamRolesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TeamRole) admin.UpdateTeamRolesApiRequest); ok { - r0 = rf(ctx, groupId, teamId, teamRole) - } else { - r0 = ret.Get(0).(admin.UpdateTeamRolesApiRequest) - } - - return r0 -} - -// TeamsApi_UpdateTeamRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRoles' -type TeamsApi_UpdateTeamRoles_Call struct { - *mock.Call -} - -// UpdateTeamRoles is a helper method to define mock.On call -// - ctx context.Context -// - groupId string -// - teamId string -// - teamRole *admin.TeamRole -func (_e *TeamsApi_Expecter) UpdateTeamRoles(ctx interface{}, groupId interface{}, teamId interface{}, teamRole interface{}) *TeamsApi_UpdateTeamRoles_Call { - return &TeamsApi_UpdateTeamRoles_Call{Call: _e.mock.On("UpdateTeamRoles", ctx, groupId, teamId, teamRole)} -} - -func (_c *TeamsApi_UpdateTeamRoles_Call) Run(run func(ctx context.Context, groupId string, teamId string, teamRole *admin.TeamRole)) *TeamsApi_UpdateTeamRoles_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TeamRole)) - }) - return _c -} - -func (_c *TeamsApi_UpdateTeamRoles_Call) Return(_a0 admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRoles_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_UpdateTeamRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.TeamRole) admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRoles_Call { - _c.Call.Return(run) - return _c -} - -// UpdateTeamRolesExecute provides a mock function with given fields: r -func (_m *TeamsApi) UpdateTeamRolesExecute(r admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) { - ret := _m.Called(r) - - if len(ret) == 0 { - panic("no return value specified for UpdateTeamRolesExecute") - } - - var r0 *admin.PaginatedTeamRole - var r1 *http.Response - var r2 error - if rf, ok := ret.Get(0).(func(admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok { - return rf(r) - } - if rf, ok := ret.Get(0).(func(admin.UpdateTeamRolesApiRequest) *admin.PaginatedTeamRole); ok { - r0 = rf(r) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*admin.PaginatedTeamRole) - } - } - - if rf, ok := ret.Get(1).(func(admin.UpdateTeamRolesApiRequest) *http.Response); ok { - r1 = rf(r) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*http.Response) - } - } - - if rf, ok := ret.Get(2).(func(admin.UpdateTeamRolesApiRequest) error); ok { - r2 = rf(r) - } else { - r2 = ret.Error(2) - } - - return r0, r1, r2 -} - -// TeamsApi_UpdateTeamRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRolesExecute' -type TeamsApi_UpdateTeamRolesExecute_Call struct { - *mock.Call -} - -// UpdateTeamRolesExecute is a helper method to define mock.On call -// - r admin.UpdateTeamRolesApiRequest -func (_e *TeamsApi_Expecter) UpdateTeamRolesExecute(r interface{}) *TeamsApi_UpdateTeamRolesExecute_Call { - return &TeamsApi_UpdateTeamRolesExecute_Call{Call: _e.mock.On("UpdateTeamRolesExecute", r)} -} - -func (_c *TeamsApi_UpdateTeamRolesExecute_Call) Run(run func(r admin.UpdateTeamRolesApiRequest)) *TeamsApi_UpdateTeamRolesExecute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(admin.UpdateTeamRolesApiRequest)) - }) - return _c -} - -func (_c *TeamsApi_UpdateTeamRolesExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_UpdateTeamRolesExecute_Call { - _c.Call.Return(_a0, _a1, _a2) - return _c -} - -func (_c *TeamsApi_UpdateTeamRolesExecute_Call) RunAndReturn(run func(admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_UpdateTeamRolesExecute_Call { - _c.Call.Return(run) - return _c -} - -// UpdateTeamRolesWithParams provides a mock function with given fields: ctx, args -func (_m *TeamsApi) UpdateTeamRolesWithParams(ctx context.Context, args *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest { - ret := _m.Called(ctx, args) - - if len(ret) == 0 { - panic("no return value specified for UpdateTeamRolesWithParams") - } - - var r0 admin.UpdateTeamRolesApiRequest - if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest); ok { - r0 = rf(ctx, args) - } else { - r0 = ret.Get(0).(admin.UpdateTeamRolesApiRequest) - } - - return r0 -} - -// TeamsApi_UpdateTeamRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRolesWithParams' -type TeamsApi_UpdateTeamRolesWithParams_Call struct { - *mock.Call -} - -// UpdateTeamRolesWithParams is a helper method to define mock.On call -// - ctx context.Context -// - args *admin.UpdateTeamRolesApiParams -func (_e *TeamsApi_Expecter) UpdateTeamRolesWithParams(ctx interface{}, args interface{}) *TeamsApi_UpdateTeamRolesWithParams_Call { - return &TeamsApi_UpdateTeamRolesWithParams_Call{Call: _e.mock.On("UpdateTeamRolesWithParams", ctx, args)} -} - -func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateTeamRolesApiParams)) *TeamsApi_UpdateTeamRolesWithParams_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*admin.UpdateTeamRolesApiParams)) - }) - return _c -} - -func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) Return(_a0 admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRolesWithParams_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRolesWithParams_Call { - _c.Call.Return(run) - return _c -} - -// NewTeamsApi creates a new instance of TeamsApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewTeamsApi(t interface { - mock.TestingT - Cleanup(func()) -}) *TeamsApi { - mock := &TeamsApi{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/scripts/update-sdk.sh b/scripts/update-sdk.sh index 1b7451f0cc..b31a10caf4 100755 --- a/scripts/update-sdk.sh +++ b/scripts/update-sdk.sh @@ -22,9 +22,4 @@ LATEST_SDK_RELEASE=$(echo "${LATEST_SDK_TAG}" | cut -d '.' -f 1) echo "==> Updating SDK to latest major version ${LATEST_SDK_TAG}" gomajor get "go.mongodb.org/atlas-sdk/${LATEST_SDK_RELEASE}@${LATEST_SDK_TAG}" go mod tidy - -LATEST_SDK_STRIPPED_MAYOR_VERSION="${LATEST_SDK_RELEASE%%.*}" -echo "==> Adjusting version defined in mockery file to ${LATEST_SDK_STRIPPED_MAYOR_VERSION}" -perl -i -pe "s|go.mongodb.org/atlas-sdk/v[0-9]{11}/admin|go.mongodb.org/atlas-sdk/${LATEST_SDK_STRIPPED_MAYOR_VERSION}/admin|g" .mockery.yaml - echo "Done"