From ad27ab20490ed40d2c4c14863aa34583c2a5cccf Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Sat, 23 Mar 2024 18:04:21 +0100 Subject: [PATCH 1/9] mockery config --- .github/workflows/autoupdate-preview.yaml | 4 ++++ .github/workflows/autoupdate-prod.yaml | 4 ++++ .mockery.yaml | 11 +++++++++++ tools/Makefile | 5 +++++ tools/releaser/scripts/version-paths.sh | 2 +- 5 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 .mockery.yaml diff --git a/.github/workflows/autoupdate-preview.yaml b/.github/workflows/autoupdate-preview.yaml index 3ae6bf80c..e71abacd5 100644 --- a/.github/workflows/autoupdate-preview.yaml +++ b/.github/workflows/autoupdate-preview.yaml @@ -29,6 +29,10 @@ jobs: if: steps.verify-changed-files.outputs.files_changed == 'true' working-directory: ./tools run: make clean_and_generate + - name: Run mock generation + working-directory: ./tools + if: steps.verify-changed-files.outputs.files_changed == 'true' + run: make generate_mocks - uses: peter-evans/create-pull-request@v6 if: steps.verify-changed-files.outputs.files_changed == 'true' env: diff --git a/.github/workflows/autoupdate-prod.yaml b/.github/workflows/autoupdate-prod.yaml index dbcec1e82..7c63df835 100644 --- a/.github/workflows/autoupdate-prod.yaml +++ b/.github/workflows/autoupdate-prod.yaml @@ -50,6 +50,10 @@ jobs: working-directory: ./tools run: | npm install && npm run format + - name: Run mock generation + working-directory: ./tools + if: steps.verify-changed-files.outputs.files_changed == 'true' + run: make generate_mocks - uses: peter-evans/create-pull-request@v6 if: steps.verify-changed-files.outputs.files_changed == 'true' env: diff --git a/.mockery.yaml b/.mockery.yaml new file mode 100644 index 000000000..8989a8084 --- /dev/null +++ b/.mockery.yaml @@ -0,0 +1,11 @@ +with-expecter: true +disable-version-string: true +dir: ../mockadmin +outpkg: mockadmin +filename: "{{ .InterfaceName | snakecase }}.go" +mockname: "{{.InterfaceName}}" + +packages: + go.mongodb.org/atlas-sdk/v20231115008/admin: + config: + include-regex: ".*Api" diff --git a/tools/Makefile b/tools/Makefile index 5597854ed..3d12b11bb 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -41,3 +41,8 @@ new-release: update-version: ## When manually updating major version ./releaser/scripts/update-version.sh + +.PHONY: generate_mocks +generate_mocks: + go install github.com/vektra/mockery/v2@v2.42.0 && mockery + diff --git a/tools/releaser/scripts/version-paths.sh b/tools/releaser/scripts/version-paths.sh index baf3de60d..4771defd4 100644 --- a/tools/releaser/scripts/version-paths.sh +++ b/tools/releaser/scripts/version-paths.sh @@ -1,3 +1,3 @@ #!/bin/bash -export VERSION_UPDATE_PATHS="../**/*.go,../**/*.md,../tools/**/*.mustache,../go.mod,../.github/workflows/autoupdate-dev.yaml" +export VERSION_UPDATE_PATHS="../**/*.go,../**/*.md,../tools/**/*.mustache,../go.mod,../.mockery.yaml" From d116d18223c67463361812d6667d3c001c3e6543 Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Sat, 23 Mar 2024 18:10:56 +0100 Subject: [PATCH 2/9] Testify go libraries --- go.mod | 8 ++++++++ go.sum | 12 ++++++++++++ 2 files changed, 20 insertions(+) diff --git a/go.mod b/go.mod index bbbc0fbf3..59c00c8e6 100644 --- a/go.mod +++ b/go.mod @@ -6,3 +6,11 @@ require ( github.com/go-test/deep v1.1.0 github.com/mongodb-forks/digest v1.0.5 ) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/testify v1.9.0 + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum index cf36f70b8..c02d945a9 100644 --- a/go.sum +++ b/go.sum @@ -1,4 +1,16 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-test/deep v1.1.0 h1:WOcxcdHcvdgThNXjw0t76K42FXTU7HpNQWHpA2HHNlg= github.com/go-test/deep v1.1.0/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= github.com/mongodb-forks/digest v1.0.5 h1:EJu3wtLZcA0HCvsZpX5yuD193/sW9tHiNvrEM5apXMk= github.com/mongodb-forks/digest v1.0.5/go.mod h1:rb+EX8zotClD5Dj4NdgxnJXG9nwrlx3NWKJ8xttz1Dg= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= From 25adf0a2d52d58cfff29adea84b06910677aab10 Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Sat, 23 Mar 2024 18:12:27 +0100 Subject: [PATCH 3/9] Mockery generated files --- mockadmin/access_tracking_api.go | 364 ++ mockadmin/alert_configurations_api.go | 1326 +++++ mockadmin/alerts_api.go | 688 +++ mockadmin/atlas_search_api.go | 1498 ++++++ mockadmin/auditing_api.go | 363 ++ mockadmin/aws_clusters_dns_api.go | 363 ++ mockadmin/cloud_backups_api.go | 4752 +++++++++++++++++ mockadmin/cloud_migration_service_api.go | 1325 +++++ mockadmin/cloud_provider_access_api.go | 842 +++ mockadmin/cluster_outage_simulation_api.go | 527 ++ mockadmin/clusters_api.go | 2450 +++++++++ mockadmin/custom_database_roles_api.go | 841 +++ mockadmin/data_federation_api.go | 2313 ++++++++ mockadmin/data_lake_pipelines_api.go | 2149 ++++++++ mockadmin/database_users_api.go | 853 +++ ..._rest_using_customer_key_management_api.go | 363 ++ mockadmin/events_api.go | 686 +++ mockadmin/federated_authentication_api.go | 2921 ++++++++++ mockadmin/global_clusters_api.go | 852 +++ mockadmin/invoices_api.go | 1004 ++++ mockadmin/ldap_configuration_api.go | 848 +++ mockadmin/legacy_backup_api.go | 1667 ++++++ mockadmin/legacy_backup_restore_jobs_api.go | 203 + mockadmin/maintenance_windows_api.go | 819 +++ mockadmin/mongo_db_cloud_users_api.go | 523 ++ mockadmin/monitoring_and_logs_api.go | 2319 ++++++++ mockadmin/network_peering_api.go | 2144 ++++++++ mockadmin/online_archive_api.go | 1019 ++++ mockadmin/organizations_api.go | 2787 ++++++++++ mockadmin/performance_advisor_api.go | 1152 ++++ mockadmin/private_endpoint_services_api.go | 1505 ++++++ mockadmin/programmatic_api_keys_api.go | 2312 ++++++++ mockadmin/project_ip_access_list_api.go | 849 +++ mockadmin/projects_api.go | 3749 +++++++++++++ mockadmin/push_based_log_export_api.go | 659 +++ mockadmin/rolling_index_api.go | 194 + mockadmin/root_api.go | 360 ++ mockadmin/serverless_instances_api.go | 850 +++ mockadmin/serverless_private_endpoints_api.go | 855 +++ mockadmin/shared_tier_restore_jobs_api.go | 528 ++ mockadmin/shared_tier_snapshots_api.go | 528 ++ mockadmin/streams_api.go | 1829 +++++++ mockadmin/teams_api.go | 2130 ++++++++ mockadmin/third_party_integrations_api.go | 851 +++ mockadmin/x509_authentication_api.go | 524 ++ 45 files changed, 57684 insertions(+) create mode 100644 mockadmin/access_tracking_api.go create mode 100644 mockadmin/alert_configurations_api.go create mode 100644 mockadmin/alerts_api.go create mode 100644 mockadmin/atlas_search_api.go create mode 100644 mockadmin/auditing_api.go create mode 100644 mockadmin/aws_clusters_dns_api.go create mode 100644 mockadmin/cloud_backups_api.go create mode 100644 mockadmin/cloud_migration_service_api.go create mode 100644 mockadmin/cloud_provider_access_api.go create mode 100644 mockadmin/cluster_outage_simulation_api.go create mode 100644 mockadmin/clusters_api.go create mode 100644 mockadmin/custom_database_roles_api.go create mode 100644 mockadmin/data_federation_api.go create mode 100644 mockadmin/data_lake_pipelines_api.go create mode 100644 mockadmin/database_users_api.go create mode 100644 mockadmin/encryption_at_rest_using_customer_key_management_api.go create mode 100644 mockadmin/events_api.go create mode 100644 mockadmin/federated_authentication_api.go create mode 100644 mockadmin/global_clusters_api.go create mode 100644 mockadmin/invoices_api.go create mode 100644 mockadmin/ldap_configuration_api.go create mode 100644 mockadmin/legacy_backup_api.go create mode 100644 mockadmin/legacy_backup_restore_jobs_api.go create mode 100644 mockadmin/maintenance_windows_api.go create mode 100644 mockadmin/mongo_db_cloud_users_api.go create mode 100644 mockadmin/monitoring_and_logs_api.go create mode 100644 mockadmin/network_peering_api.go create mode 100644 mockadmin/online_archive_api.go create mode 100644 mockadmin/organizations_api.go create mode 100644 mockadmin/performance_advisor_api.go create mode 100644 mockadmin/private_endpoint_services_api.go create mode 100644 mockadmin/programmatic_api_keys_api.go create mode 100644 mockadmin/project_ip_access_list_api.go create mode 100644 mockadmin/projects_api.go create mode 100644 mockadmin/push_based_log_export_api.go create mode 100644 mockadmin/rolling_index_api.go create mode 100644 mockadmin/root_api.go create mode 100644 mockadmin/serverless_instances_api.go create mode 100644 mockadmin/serverless_private_endpoints_api.go create mode 100644 mockadmin/shared_tier_restore_jobs_api.go create mode 100644 mockadmin/shared_tier_snapshots_api.go create mode 100644 mockadmin/streams_api.go create mode 100644 mockadmin/teams_api.go create mode 100644 mockadmin/third_party_integrations_api.go create mode 100644 mockadmin/x509_authentication_api.go diff --git a/mockadmin/access_tracking_api.go b/mockadmin/access_tracking_api.go new file mode 100644 index 000000000..9c3328c3a --- /dev/null +++ b/mockadmin/access_tracking_api.go @@ -0,0 +1,364 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// AccessTrackingApi is an autogenerated mock type for the AccessTrackingApi type +type AccessTrackingApi struct { + mock.Mock +} + +type AccessTrackingApi_Expecter struct { + mock *mock.Mock +} + +func (_m *AccessTrackingApi) EXPECT() *AccessTrackingApi_Expecter { + return &AccessTrackingApi_Expecter{mock: &_m.Mock} +} + +// ListAccessLogsByClusterName provides a mock function with given fields: ctx, groupId, clusterName +func (_m *AccessTrackingApi) ListAccessLogsByClusterName(ctx context.Context, groupId string, clusterName string) admin.ListAccessLogsByClusterNameApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByClusterName") + } + + var r0 admin.ListAccessLogsByClusterNameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListAccessLogsByClusterNameApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListAccessLogsByClusterNameApiRequest) + } + + return r0 +} + +// AccessTrackingApi_ListAccessLogsByClusterName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByClusterName' +type AccessTrackingApi_ListAccessLogsByClusterName_Call struct { + *mock.Call +} + +// ListAccessLogsByClusterName is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByClusterName(ctx interface{}, groupId interface{}, clusterName interface{}) *AccessTrackingApi_ListAccessLogsByClusterName_Call { + return &AccessTrackingApi_ListAccessLogsByClusterName_Call{Call: _e.mock.On("ListAccessLogsByClusterName", ctx, groupId, clusterName)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterName_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *AccessTrackingApi_ListAccessLogsByClusterName_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterName_Call) Return(_a0 admin.ListAccessLogsByClusterNameApiRequest) *AccessTrackingApi_ListAccessLogsByClusterName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterName_Call) RunAndReturn(run func(context.Context, string, string) admin.ListAccessLogsByClusterNameApiRequest) *AccessTrackingApi_ListAccessLogsByClusterName_Call { + _c.Call.Return(run) + return _c +} + +// ListAccessLogsByClusterNameExecute provides a mock function with given fields: r +func (_m *AccessTrackingApi) ListAccessLogsByClusterNameExecute(r admin.ListAccessLogsByClusterNameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByClusterNameExecute") + } + + var r0 *admin.MongoDBAccessLogsList + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAccessLogsByClusterNameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAccessLogsByClusterNameApiRequest) *admin.MongoDBAccessLogsList); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MongoDBAccessLogsList) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAccessLogsByClusterNameApiRequest) *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.ListAccessLogsByClusterNameApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByClusterNameExecute' +type AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call struct { + *mock.Call +} + +// ListAccessLogsByClusterNameExecute is a helper method to define mock.On call +// - r admin.ListAccessLogsByClusterNameApiRequest +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByClusterNameExecute(r interface{}) *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call { + return &AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call{Call: _e.mock.On("ListAccessLogsByClusterNameExecute", r)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call) Run(run func(r admin.ListAccessLogsByClusterNameApiRequest)) *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAccessLogsByClusterNameApiRequest)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call) Return(_a0 *admin.MongoDBAccessLogsList, _a1 *http.Response, _a2 error) *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call) RunAndReturn(run func(admin.ListAccessLogsByClusterNameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error)) *AccessTrackingApi_ListAccessLogsByClusterNameExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAccessLogsByClusterNameWithParams provides a mock function with given fields: ctx, args +func (_m *AccessTrackingApi) ListAccessLogsByClusterNameWithParams(ctx context.Context, args *admin.ListAccessLogsByClusterNameApiParams) admin.ListAccessLogsByClusterNameApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByClusterNameWithParams") + } + + var r0 admin.ListAccessLogsByClusterNameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAccessLogsByClusterNameApiParams) admin.ListAccessLogsByClusterNameApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAccessLogsByClusterNameApiRequest) + } + + return r0 +} + +// AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByClusterNameWithParams' +type AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call struct { + *mock.Call +} + +// ListAccessLogsByClusterNameWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAccessLogsByClusterNameApiParams +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByClusterNameWithParams(ctx interface{}, args interface{}) *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call { + return &AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call{Call: _e.mock.On("ListAccessLogsByClusterNameWithParams", ctx, args)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAccessLogsByClusterNameApiParams)) *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAccessLogsByClusterNameApiParams)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call) Return(_a0 admin.ListAccessLogsByClusterNameApiRequest) *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAccessLogsByClusterNameApiParams) admin.ListAccessLogsByClusterNameApiRequest) *AccessTrackingApi_ListAccessLogsByClusterNameWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAccessLogsByHostname provides a mock function with given fields: ctx, groupId, hostname +func (_m *AccessTrackingApi) ListAccessLogsByHostname(ctx context.Context, groupId string, hostname string) admin.ListAccessLogsByHostnameApiRequest { + ret := _m.Called(ctx, groupId, hostname) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByHostname") + } + + var r0 admin.ListAccessLogsByHostnameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListAccessLogsByHostnameApiRequest); ok { + r0 = rf(ctx, groupId, hostname) + } else { + r0 = ret.Get(0).(admin.ListAccessLogsByHostnameApiRequest) + } + + return r0 +} + +// AccessTrackingApi_ListAccessLogsByHostname_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByHostname' +type AccessTrackingApi_ListAccessLogsByHostname_Call struct { + *mock.Call +} + +// ListAccessLogsByHostname is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - hostname string +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByHostname(ctx interface{}, groupId interface{}, hostname interface{}) *AccessTrackingApi_ListAccessLogsByHostname_Call { + return &AccessTrackingApi_ListAccessLogsByHostname_Call{Call: _e.mock.On("ListAccessLogsByHostname", ctx, groupId, hostname)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostname_Call) Run(run func(ctx context.Context, groupId string, hostname string)) *AccessTrackingApi_ListAccessLogsByHostname_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostname_Call) Return(_a0 admin.ListAccessLogsByHostnameApiRequest) *AccessTrackingApi_ListAccessLogsByHostname_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostname_Call) RunAndReturn(run func(context.Context, string, string) admin.ListAccessLogsByHostnameApiRequest) *AccessTrackingApi_ListAccessLogsByHostname_Call { + _c.Call.Return(run) + return _c +} + +// ListAccessLogsByHostnameExecute provides a mock function with given fields: r +func (_m *AccessTrackingApi) ListAccessLogsByHostnameExecute(r admin.ListAccessLogsByHostnameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByHostnameExecute") + } + + var r0 *admin.MongoDBAccessLogsList + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAccessLogsByHostnameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAccessLogsByHostnameApiRequest) *admin.MongoDBAccessLogsList); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MongoDBAccessLogsList) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAccessLogsByHostnameApiRequest) *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.ListAccessLogsByHostnameApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AccessTrackingApi_ListAccessLogsByHostnameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByHostnameExecute' +type AccessTrackingApi_ListAccessLogsByHostnameExecute_Call struct { + *mock.Call +} + +// ListAccessLogsByHostnameExecute is a helper method to define mock.On call +// - r admin.ListAccessLogsByHostnameApiRequest +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByHostnameExecute(r interface{}) *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call { + return &AccessTrackingApi_ListAccessLogsByHostnameExecute_Call{Call: _e.mock.On("ListAccessLogsByHostnameExecute", r)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call) Run(run func(r admin.ListAccessLogsByHostnameApiRequest)) *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAccessLogsByHostnameApiRequest)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call) Return(_a0 *admin.MongoDBAccessLogsList, _a1 *http.Response, _a2 error) *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call) RunAndReturn(run func(admin.ListAccessLogsByHostnameApiRequest) (*admin.MongoDBAccessLogsList, *http.Response, error)) *AccessTrackingApi_ListAccessLogsByHostnameExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAccessLogsByHostnameWithParams provides a mock function with given fields: ctx, args +func (_m *AccessTrackingApi) ListAccessLogsByHostnameWithParams(ctx context.Context, args *admin.ListAccessLogsByHostnameApiParams) admin.ListAccessLogsByHostnameApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAccessLogsByHostnameWithParams") + } + + var r0 admin.ListAccessLogsByHostnameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAccessLogsByHostnameApiParams) admin.ListAccessLogsByHostnameApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAccessLogsByHostnameApiRequest) + } + + return r0 +} + +// AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAccessLogsByHostnameWithParams' +type AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call struct { + *mock.Call +} + +// ListAccessLogsByHostnameWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAccessLogsByHostnameApiParams +func (_e *AccessTrackingApi_Expecter) ListAccessLogsByHostnameWithParams(ctx interface{}, args interface{}) *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call { + return &AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call{Call: _e.mock.On("ListAccessLogsByHostnameWithParams", ctx, args)} +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAccessLogsByHostnameApiParams)) *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAccessLogsByHostnameApiParams)) + }) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call) Return(_a0 admin.ListAccessLogsByHostnameApiRequest) *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAccessLogsByHostnameApiParams) admin.ListAccessLogsByHostnameApiRequest) *AccessTrackingApi_ListAccessLogsByHostnameWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewAccessTrackingApi creates a new instance of AccessTrackingApi. 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 NewAccessTrackingApi(t interface { + mock.TestingT + Cleanup(func()) +}) *AccessTrackingApi { + mock := &AccessTrackingApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/alert_configurations_api.go b/mockadmin/alert_configurations_api.go new file mode 100644 index 000000000..a5a281843 --- /dev/null +++ b/mockadmin/alert_configurations_api.go @@ -0,0 +1,1326 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// AlertConfigurationsApi is an autogenerated mock type for the AlertConfigurationsApi type +type AlertConfigurationsApi struct { + mock.Mock +} + +type AlertConfigurationsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *AlertConfigurationsApi) EXPECT() *AlertConfigurationsApi_Expecter { + return &AlertConfigurationsApi_Expecter{mock: &_m.Mock} +} + +// CreateAlertConfiguration provides a mock function with given fields: ctx, groupId, groupAlertsConfig +func (_m *AlertConfigurationsApi) CreateAlertConfiguration(ctx context.Context, groupId string, groupAlertsConfig *admin.GroupAlertsConfig) admin.CreateAlertConfigurationApiRequest { + ret := _m.Called(ctx, groupId, groupAlertsConfig) + + if len(ret) == 0 { + panic("no return value specified for CreateAlertConfiguration") + } + + var r0 admin.CreateAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupAlertsConfig) admin.CreateAlertConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, groupAlertsConfig) + } else { + r0 = ret.Get(0).(admin.CreateAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_CreateAlertConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlertConfiguration' +type AlertConfigurationsApi_CreateAlertConfiguration_Call struct { + *mock.Call +} + +// CreateAlertConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - groupAlertsConfig *admin.GroupAlertsConfig +func (_e *AlertConfigurationsApi_Expecter) CreateAlertConfiguration(ctx interface{}, groupId interface{}, groupAlertsConfig interface{}) *AlertConfigurationsApi_CreateAlertConfiguration_Call { + return &AlertConfigurationsApi_CreateAlertConfiguration_Call{Call: _e.mock.On("CreateAlertConfiguration", ctx, groupId, groupAlertsConfig)} +} + +func (_c *AlertConfigurationsApi_CreateAlertConfiguration_Call) Run(run func(ctx context.Context, groupId string, groupAlertsConfig *admin.GroupAlertsConfig)) *AlertConfigurationsApi_CreateAlertConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupAlertsConfig)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfiguration_Call) Return(_a0 admin.CreateAlertConfigurationApiRequest) *AlertConfigurationsApi_CreateAlertConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.GroupAlertsConfig) admin.CreateAlertConfigurationApiRequest) *AlertConfigurationsApi_CreateAlertConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// CreateAlertConfigurationExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) CreateAlertConfigurationExecute(r admin.CreateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateAlertConfigurationExecute") + } + + var r0 *admin.GroupAlertsConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateAlertConfigurationApiRequest) *admin.GroupAlertsConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupAlertsConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateAlertConfigurationApiRequest) *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.CreateAlertConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_CreateAlertConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlertConfigurationExecute' +type AlertConfigurationsApi_CreateAlertConfigurationExecute_Call struct { + *mock.Call +} + +// CreateAlertConfigurationExecute is a helper method to define mock.On call +// - r admin.CreateAlertConfigurationApiRequest +func (_e *AlertConfigurationsApi_Expecter) CreateAlertConfigurationExecute(r interface{}) *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call { + return &AlertConfigurationsApi_CreateAlertConfigurationExecute_Call{Call: _e.mock.On("CreateAlertConfigurationExecute", r)} +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call) Run(run func(r admin.CreateAlertConfigurationApiRequest)) *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateAlertConfigurationApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call) Return(_a0 *admin.GroupAlertsConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call) RunAndReturn(run func(admin.CreateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)) *AlertConfigurationsApi_CreateAlertConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateAlertConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) CreateAlertConfigurationWithParams(ctx context.Context, args *admin.CreateAlertConfigurationApiParams) admin.CreateAlertConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateAlertConfigurationWithParams") + } + + var r0 admin.CreateAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateAlertConfigurationApiParams) admin.CreateAlertConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAlertConfigurationWithParams' +type AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call struct { + *mock.Call +} + +// CreateAlertConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateAlertConfigurationApiParams +func (_e *AlertConfigurationsApi_Expecter) CreateAlertConfigurationWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call { + return &AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call{Call: _e.mock.On("CreateAlertConfigurationWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateAlertConfigurationApiParams)) *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateAlertConfigurationApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call) Return(_a0 admin.CreateAlertConfigurationApiRequest) *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateAlertConfigurationApiParams) admin.CreateAlertConfigurationApiRequest) *AlertConfigurationsApi_CreateAlertConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAlertConfiguration provides a mock function with given fields: ctx, groupId, alertConfigId +func (_m *AlertConfigurationsApi) DeleteAlertConfiguration(ctx context.Context, groupId string, alertConfigId string) admin.DeleteAlertConfigurationApiRequest { + ret := _m.Called(ctx, groupId, alertConfigId) + + if len(ret) == 0 { + panic("no return value specified for DeleteAlertConfiguration") + } + + var r0 admin.DeleteAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteAlertConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, alertConfigId) + } else { + r0 = ret.Get(0).(admin.DeleteAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_DeleteAlertConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlertConfiguration' +type AlertConfigurationsApi_DeleteAlertConfiguration_Call struct { + *mock.Call +} + +// DeleteAlertConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertConfigId string +func (_e *AlertConfigurationsApi_Expecter) DeleteAlertConfiguration(ctx interface{}, groupId interface{}, alertConfigId interface{}) *AlertConfigurationsApi_DeleteAlertConfiguration_Call { + return &AlertConfigurationsApi_DeleteAlertConfiguration_Call{Call: _e.mock.On("DeleteAlertConfiguration", ctx, groupId, alertConfigId)} +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfiguration_Call) Run(run func(ctx context.Context, groupId string, alertConfigId string)) *AlertConfigurationsApi_DeleteAlertConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfiguration_Call) Return(_a0 admin.DeleteAlertConfigurationApiRequest) *AlertConfigurationsApi_DeleteAlertConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfiguration_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteAlertConfigurationApiRequest) *AlertConfigurationsApi_DeleteAlertConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAlertConfigurationExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) DeleteAlertConfigurationExecute(r admin.DeleteAlertConfigurationApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteAlertConfigurationExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeleteAlertConfigurationApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteAlertConfigurationApiRequest) *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.DeleteAlertConfigurationApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlertConfigurationExecute' +type AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call struct { + *mock.Call +} + +// DeleteAlertConfigurationExecute is a helper method to define mock.On call +// - r admin.DeleteAlertConfigurationApiRequest +func (_e *AlertConfigurationsApi_Expecter) DeleteAlertConfigurationExecute(r interface{}) *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call { + return &AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call{Call: _e.mock.On("DeleteAlertConfigurationExecute", r)} +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call) Run(run func(r admin.DeleteAlertConfigurationApiRequest)) *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteAlertConfigurationApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call) Return(_a0 *http.Response, _a1 error) *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call) RunAndReturn(run func(admin.DeleteAlertConfigurationApiRequest) (*http.Response, error)) *AlertConfigurationsApi_DeleteAlertConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAlertConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) DeleteAlertConfigurationWithParams(ctx context.Context, args *admin.DeleteAlertConfigurationApiParams) admin.DeleteAlertConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteAlertConfigurationWithParams") + } + + var r0 admin.DeleteAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteAlertConfigurationApiParams) admin.DeleteAlertConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlertConfigurationWithParams' +type AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call struct { + *mock.Call +} + +// DeleteAlertConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteAlertConfigurationApiParams +func (_e *AlertConfigurationsApi_Expecter) DeleteAlertConfigurationWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call { + return &AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call{Call: _e.mock.On("DeleteAlertConfigurationWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteAlertConfigurationApiParams)) *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteAlertConfigurationApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call) Return(_a0 admin.DeleteAlertConfigurationApiRequest) *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAlertConfigurationApiParams) admin.DeleteAlertConfigurationApiRequest) *AlertConfigurationsApi_DeleteAlertConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetAlertConfiguration provides a mock function with given fields: ctx, groupId, alertConfigId +func (_m *AlertConfigurationsApi) GetAlertConfiguration(ctx context.Context, groupId string, alertConfigId string) admin.GetAlertConfigurationApiRequest { + ret := _m.Called(ctx, groupId, alertConfigId) + + if len(ret) == 0 { + panic("no return value specified for GetAlertConfiguration") + } + + var r0 admin.GetAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetAlertConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, alertConfigId) + } else { + r0 = ret.Get(0).(admin.GetAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_GetAlertConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlertConfiguration' +type AlertConfigurationsApi_GetAlertConfiguration_Call struct { + *mock.Call +} + +// GetAlertConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertConfigId string +func (_e *AlertConfigurationsApi_Expecter) GetAlertConfiguration(ctx interface{}, groupId interface{}, alertConfigId interface{}) *AlertConfigurationsApi_GetAlertConfiguration_Call { + return &AlertConfigurationsApi_GetAlertConfiguration_Call{Call: _e.mock.On("GetAlertConfiguration", ctx, groupId, alertConfigId)} +} + +func (_c *AlertConfigurationsApi_GetAlertConfiguration_Call) Run(run func(ctx context.Context, groupId string, alertConfigId string)) *AlertConfigurationsApi_GetAlertConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfiguration_Call) Return(_a0 admin.GetAlertConfigurationApiRequest) *AlertConfigurationsApi_GetAlertConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfiguration_Call) RunAndReturn(run func(context.Context, string, string) admin.GetAlertConfigurationApiRequest) *AlertConfigurationsApi_GetAlertConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetAlertConfigurationExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) GetAlertConfigurationExecute(r admin.GetAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetAlertConfigurationExecute") + } + + var r0 *admin.GroupAlertsConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetAlertConfigurationApiRequest) *admin.GroupAlertsConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupAlertsConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetAlertConfigurationApiRequest) *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.GetAlertConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_GetAlertConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlertConfigurationExecute' +type AlertConfigurationsApi_GetAlertConfigurationExecute_Call struct { + *mock.Call +} + +// GetAlertConfigurationExecute is a helper method to define mock.On call +// - r admin.GetAlertConfigurationApiRequest +func (_e *AlertConfigurationsApi_Expecter) GetAlertConfigurationExecute(r interface{}) *AlertConfigurationsApi_GetAlertConfigurationExecute_Call { + return &AlertConfigurationsApi_GetAlertConfigurationExecute_Call{Call: _e.mock.On("GetAlertConfigurationExecute", r)} +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationExecute_Call) Run(run func(r admin.GetAlertConfigurationApiRequest)) *AlertConfigurationsApi_GetAlertConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetAlertConfigurationApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationExecute_Call) Return(_a0 *admin.GroupAlertsConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_GetAlertConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationExecute_Call) RunAndReturn(run func(admin.GetAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)) *AlertConfigurationsApi_GetAlertConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetAlertConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) GetAlertConfigurationWithParams(ctx context.Context, args *admin.GetAlertConfigurationApiParams) admin.GetAlertConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetAlertConfigurationWithParams") + } + + var r0 admin.GetAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAlertConfigurationApiParams) admin.GetAlertConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_GetAlertConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlertConfigurationWithParams' +type AlertConfigurationsApi_GetAlertConfigurationWithParams_Call struct { + *mock.Call +} + +// GetAlertConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetAlertConfigurationApiParams +func (_e *AlertConfigurationsApi_Expecter) GetAlertConfigurationWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call { + return &AlertConfigurationsApi_GetAlertConfigurationWithParams_Call{Call: _e.mock.On("GetAlertConfigurationWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAlertConfigurationApiParams)) *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetAlertConfigurationApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call) Return(_a0 admin.GetAlertConfigurationApiRequest) *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAlertConfigurationApiParams) admin.GetAlertConfigurationApiRequest) *AlertConfigurationsApi_GetAlertConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationMatchersFieldNames provides a mock function with given fields: ctx +func (_m *AlertConfigurationsApi) ListAlertConfigurationMatchersFieldNames(ctx context.Context) admin.ListAlertConfigurationMatchersFieldNamesApiRequest { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationMatchersFieldNames") + } + + var r0 admin.ListAlertConfigurationMatchersFieldNamesApiRequest + if rf, ok := ret.Get(0).(func(context.Context) admin.ListAlertConfigurationMatchersFieldNamesApiRequest); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationMatchersFieldNames' +type AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call struct { + *mock.Call +} + +// ListAlertConfigurationMatchersFieldNames is a helper method to define mock.On call +// - ctx context.Context +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationMatchersFieldNames(ctx interface{}) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call { + return &AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call{Call: _e.mock.On("ListAlertConfigurationMatchersFieldNames", ctx)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call) Run(run func(ctx context.Context)) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call) Return(_a0 admin.ListAlertConfigurationMatchersFieldNamesApiRequest) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call) RunAndReturn(run func(context.Context) admin.ListAlertConfigurationMatchersFieldNamesApiRequest) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNames_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationMatchersFieldNamesExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) ListAlertConfigurationMatchersFieldNamesExecute(r admin.ListAlertConfigurationMatchersFieldNamesApiRequest) ([]string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationMatchersFieldNamesExecute") + } + + var r0 []string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) ([]string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) []string); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) *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.ListAlertConfigurationMatchersFieldNamesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationMatchersFieldNamesExecute' +type AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call struct { + *mock.Call +} + +// ListAlertConfigurationMatchersFieldNamesExecute is a helper method to define mock.On call +// - r admin.ListAlertConfigurationMatchersFieldNamesApiRequest +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationMatchersFieldNamesExecute(r interface{}) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call { + return &AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call{Call: _e.mock.On("ListAlertConfigurationMatchersFieldNamesExecute", r)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call) Run(run func(r admin.ListAlertConfigurationMatchersFieldNamesApiRequest)) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAlertConfigurationMatchersFieldNamesApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call) Return(_a0 []string, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call) RunAndReturn(run func(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) ([]string, *http.Response, error)) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationMatchersFieldNamesWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) ListAlertConfigurationMatchersFieldNamesWithParams(ctx context.Context, args *admin.ListAlertConfigurationMatchersFieldNamesApiParams) admin.ListAlertConfigurationMatchersFieldNamesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationMatchersFieldNamesWithParams") + } + + var r0 admin.ListAlertConfigurationMatchersFieldNamesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAlertConfigurationMatchersFieldNamesApiParams) admin.ListAlertConfigurationMatchersFieldNamesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationMatchersFieldNamesApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationMatchersFieldNamesWithParams' +type AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call struct { + *mock.Call +} + +// ListAlertConfigurationMatchersFieldNamesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAlertConfigurationMatchersFieldNamesApiParams +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationMatchersFieldNamesWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call { + return &AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call{Call: _e.mock.On("ListAlertConfigurationMatchersFieldNamesWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAlertConfigurationMatchersFieldNamesApiParams)) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAlertConfigurationMatchersFieldNamesApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call) Return(_a0 admin.ListAlertConfigurationMatchersFieldNamesApiRequest) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAlertConfigurationMatchersFieldNamesApiParams) admin.ListAlertConfigurationMatchersFieldNamesApiRequest) *AlertConfigurationsApi_ListAlertConfigurationMatchersFieldNamesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurations provides a mock function with given fields: ctx, groupId +func (_m *AlertConfigurationsApi) ListAlertConfigurations(ctx context.Context, groupId string) admin.ListAlertConfigurationsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurations") + } + + var r0 admin.ListAlertConfigurationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListAlertConfigurationsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationsApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurations' +type AlertConfigurationsApi_ListAlertConfigurations_Call struct { + *mock.Call +} + +// ListAlertConfigurations is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurations(ctx interface{}, groupId interface{}) *AlertConfigurationsApi_ListAlertConfigurations_Call { + return &AlertConfigurationsApi_ListAlertConfigurations_Call{Call: _e.mock.On("ListAlertConfigurations", ctx, groupId)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurations_Call) Run(run func(ctx context.Context, groupId string)) *AlertConfigurationsApi_ListAlertConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurations_Call) Return(_a0 admin.ListAlertConfigurationsApiRequest) *AlertConfigurationsApi_ListAlertConfigurations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurations_Call) RunAndReturn(run func(context.Context, string) admin.ListAlertConfigurationsApiRequest) *AlertConfigurationsApi_ListAlertConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationsByAlertId provides a mock function with given fields: ctx, groupId, alertId +func (_m *AlertConfigurationsApi) ListAlertConfigurationsByAlertId(ctx context.Context, groupId string, alertId string) admin.ListAlertConfigurationsByAlertIdApiRequest { + ret := _m.Called(ctx, groupId, alertId) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationsByAlertId") + } + + var r0 admin.ListAlertConfigurationsByAlertIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListAlertConfigurationsByAlertIdApiRequest); ok { + r0 = rf(ctx, groupId, alertId) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationsByAlertIdApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationsByAlertId' +type AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call struct { + *mock.Call +} + +// ListAlertConfigurationsByAlertId is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertId string +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationsByAlertId(ctx interface{}, groupId interface{}, alertId interface{}) *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call { + return &AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call{Call: _e.mock.On("ListAlertConfigurationsByAlertId", ctx, groupId, alertId)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call) Run(run func(ctx context.Context, groupId string, alertId string)) *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call) Return(_a0 admin.ListAlertConfigurationsByAlertIdApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call) RunAndReturn(run func(context.Context, string, string) admin.ListAlertConfigurationsByAlertIdApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsByAlertId_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationsByAlertIdExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) ListAlertConfigurationsByAlertIdExecute(r admin.ListAlertConfigurationsByAlertIdApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationsByAlertIdExecute") + } + + var r0 *admin.PaginatedAlertConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationsByAlertIdApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationsByAlertIdApiRequest) *admin.PaginatedAlertConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedAlertConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAlertConfigurationsByAlertIdApiRequest) *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.ListAlertConfigurationsByAlertIdApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationsByAlertIdExecute' +type AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call struct { + *mock.Call +} + +// ListAlertConfigurationsByAlertIdExecute is a helper method to define mock.On call +// - r admin.ListAlertConfigurationsByAlertIdApiRequest +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationsByAlertIdExecute(r interface{}) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call { + return &AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call{Call: _e.mock.On("ListAlertConfigurationsByAlertIdExecute", r)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call) Run(run func(r admin.ListAlertConfigurationsByAlertIdApiRequest)) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAlertConfigurationsByAlertIdApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call) Return(_a0 *admin.PaginatedAlertConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call) RunAndReturn(run func(admin.ListAlertConfigurationsByAlertIdApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error)) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationsByAlertIdWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) ListAlertConfigurationsByAlertIdWithParams(ctx context.Context, args *admin.ListAlertConfigurationsByAlertIdApiParams) admin.ListAlertConfigurationsByAlertIdApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationsByAlertIdWithParams") + } + + var r0 admin.ListAlertConfigurationsByAlertIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAlertConfigurationsByAlertIdApiParams) admin.ListAlertConfigurationsByAlertIdApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationsByAlertIdApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationsByAlertIdWithParams' +type AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call struct { + *mock.Call +} + +// ListAlertConfigurationsByAlertIdWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAlertConfigurationsByAlertIdApiParams +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationsByAlertIdWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call { + return &AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call{Call: _e.mock.On("ListAlertConfigurationsByAlertIdWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAlertConfigurationsByAlertIdApiParams)) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAlertConfigurationsByAlertIdApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call) Return(_a0 admin.ListAlertConfigurationsByAlertIdApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAlertConfigurationsByAlertIdApiParams) admin.ListAlertConfigurationsByAlertIdApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsByAlertIdWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationsExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) ListAlertConfigurationsExecute(r admin.ListAlertConfigurationsApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationsExecute") + } + + var r0 *admin.PaginatedAlertConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationsApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAlertConfigurationsApiRequest) *admin.PaginatedAlertConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedAlertConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAlertConfigurationsApiRequest) *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.ListAlertConfigurationsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_ListAlertConfigurationsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationsExecute' +type AlertConfigurationsApi_ListAlertConfigurationsExecute_Call struct { + *mock.Call +} + +// ListAlertConfigurationsExecute is a helper method to define mock.On call +// - r admin.ListAlertConfigurationsApiRequest +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationsExecute(r interface{}) *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call { + return &AlertConfigurationsApi_ListAlertConfigurationsExecute_Call{Call: _e.mock.On("ListAlertConfigurationsExecute", r)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call) Run(run func(r admin.ListAlertConfigurationsApiRequest)) *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAlertConfigurationsApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call) Return(_a0 *admin.PaginatedAlertConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call) RunAndReturn(run func(admin.ListAlertConfigurationsApiRequest) (*admin.PaginatedAlertConfig, *http.Response, error)) *AlertConfigurationsApi_ListAlertConfigurationsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertConfigurationsWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) ListAlertConfigurationsWithParams(ctx context.Context, args *admin.ListAlertConfigurationsApiParams) admin.ListAlertConfigurationsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAlertConfigurationsWithParams") + } + + var r0 admin.ListAlertConfigurationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAlertConfigurationsApiParams) admin.ListAlertConfigurationsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAlertConfigurationsApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertConfigurationsWithParams' +type AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call struct { + *mock.Call +} + +// ListAlertConfigurationsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAlertConfigurationsApiParams +func (_e *AlertConfigurationsApi_Expecter) ListAlertConfigurationsWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call { + return &AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call{Call: _e.mock.On("ListAlertConfigurationsWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAlertConfigurationsApiParams)) *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAlertConfigurationsApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call) Return(_a0 admin.ListAlertConfigurationsApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAlertConfigurationsApiParams) admin.ListAlertConfigurationsApiRequest) *AlertConfigurationsApi_ListAlertConfigurationsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAlertConfiguration provides a mock function with given fields: ctx, groupId, alertConfigId, alertsToggle +func (_m *AlertConfigurationsApi) ToggleAlertConfiguration(ctx context.Context, groupId string, alertConfigId string, alertsToggle *admin.AlertsToggle) admin.ToggleAlertConfigurationApiRequest { + ret := _m.Called(ctx, groupId, alertConfigId, alertsToggle) + + if len(ret) == 0 { + panic("no return value specified for ToggleAlertConfiguration") + } + + var r0 admin.ToggleAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.AlertsToggle) admin.ToggleAlertConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, alertConfigId, alertsToggle) + } else { + r0 = ret.Get(0).(admin.ToggleAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ToggleAlertConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAlertConfiguration' +type AlertConfigurationsApi_ToggleAlertConfiguration_Call struct { + *mock.Call +} + +// ToggleAlertConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertConfigId string +// - alertsToggle *admin.AlertsToggle +func (_e *AlertConfigurationsApi_Expecter) ToggleAlertConfiguration(ctx interface{}, groupId interface{}, alertConfigId interface{}, alertsToggle interface{}) *AlertConfigurationsApi_ToggleAlertConfiguration_Call { + return &AlertConfigurationsApi_ToggleAlertConfiguration_Call{Call: _e.mock.On("ToggleAlertConfiguration", ctx, groupId, alertConfigId, alertsToggle)} +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfiguration_Call) Run(run func(ctx context.Context, groupId string, alertConfigId string, alertsToggle *admin.AlertsToggle)) *AlertConfigurationsApi_ToggleAlertConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.AlertsToggle)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfiguration_Call) Return(_a0 admin.ToggleAlertConfigurationApiRequest) *AlertConfigurationsApi_ToggleAlertConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfiguration_Call) RunAndReturn(run func(context.Context, string, string, *admin.AlertsToggle) admin.ToggleAlertConfigurationApiRequest) *AlertConfigurationsApi_ToggleAlertConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAlertConfigurationExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) ToggleAlertConfigurationExecute(r admin.ToggleAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ToggleAlertConfigurationExecute") + } + + var r0 *admin.GroupAlertsConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ToggleAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ToggleAlertConfigurationApiRequest) *admin.GroupAlertsConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupAlertsConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.ToggleAlertConfigurationApiRequest) *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.ToggleAlertConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAlertConfigurationExecute' +type AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call struct { + *mock.Call +} + +// ToggleAlertConfigurationExecute is a helper method to define mock.On call +// - r admin.ToggleAlertConfigurationApiRequest +func (_e *AlertConfigurationsApi_Expecter) ToggleAlertConfigurationExecute(r interface{}) *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call { + return &AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call{Call: _e.mock.On("ToggleAlertConfigurationExecute", r)} +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call) Run(run func(r admin.ToggleAlertConfigurationApiRequest)) *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ToggleAlertConfigurationApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call) Return(_a0 *admin.GroupAlertsConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call) RunAndReturn(run func(admin.ToggleAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)) *AlertConfigurationsApi_ToggleAlertConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAlertConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) ToggleAlertConfigurationWithParams(ctx context.Context, args *admin.ToggleAlertConfigurationApiParams) admin.ToggleAlertConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ToggleAlertConfigurationWithParams") + } + + var r0 admin.ToggleAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ToggleAlertConfigurationApiParams) admin.ToggleAlertConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ToggleAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAlertConfigurationWithParams' +type AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call struct { + *mock.Call +} + +// ToggleAlertConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ToggleAlertConfigurationApiParams +func (_e *AlertConfigurationsApi_Expecter) ToggleAlertConfigurationWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call { + return &AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call{Call: _e.mock.On("ToggleAlertConfigurationWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.ToggleAlertConfigurationApiParams)) *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ToggleAlertConfigurationApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call) Return(_a0 admin.ToggleAlertConfigurationApiRequest) *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.ToggleAlertConfigurationApiParams) admin.ToggleAlertConfigurationApiRequest) *AlertConfigurationsApi_ToggleAlertConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAlertConfiguration provides a mock function with given fields: ctx, groupId, alertConfigId, groupAlertsConfig +func (_m *AlertConfigurationsApi) UpdateAlertConfiguration(ctx context.Context, groupId string, alertConfigId string, groupAlertsConfig *admin.GroupAlertsConfig) admin.UpdateAlertConfigurationApiRequest { + ret := _m.Called(ctx, groupId, alertConfigId, groupAlertsConfig) + + if len(ret) == 0 { + panic("no return value specified for UpdateAlertConfiguration") + } + + var r0 admin.UpdateAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.GroupAlertsConfig) admin.UpdateAlertConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, alertConfigId, groupAlertsConfig) + } else { + r0 = ret.Get(0).(admin.UpdateAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_UpdateAlertConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAlertConfiguration' +type AlertConfigurationsApi_UpdateAlertConfiguration_Call struct { + *mock.Call +} + +// UpdateAlertConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertConfigId string +// - groupAlertsConfig *admin.GroupAlertsConfig +func (_e *AlertConfigurationsApi_Expecter) UpdateAlertConfiguration(ctx interface{}, groupId interface{}, alertConfigId interface{}, groupAlertsConfig interface{}) *AlertConfigurationsApi_UpdateAlertConfiguration_Call { + return &AlertConfigurationsApi_UpdateAlertConfiguration_Call{Call: _e.mock.On("UpdateAlertConfiguration", ctx, groupId, alertConfigId, groupAlertsConfig)} +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfiguration_Call) Run(run func(ctx context.Context, groupId string, alertConfigId string, groupAlertsConfig *admin.GroupAlertsConfig)) *AlertConfigurationsApi_UpdateAlertConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.GroupAlertsConfig)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfiguration_Call) Return(_a0 admin.UpdateAlertConfigurationApiRequest) *AlertConfigurationsApi_UpdateAlertConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfiguration_Call) RunAndReturn(run func(context.Context, string, string, *admin.GroupAlertsConfig) admin.UpdateAlertConfigurationApiRequest) *AlertConfigurationsApi_UpdateAlertConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAlertConfigurationExecute provides a mock function with given fields: r +func (_m *AlertConfigurationsApi) UpdateAlertConfigurationExecute(r admin.UpdateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateAlertConfigurationExecute") + } + + var r0 *admin.GroupAlertsConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateAlertConfigurationApiRequest) *admin.GroupAlertsConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupAlertsConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateAlertConfigurationApiRequest) *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.UpdateAlertConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAlertConfigurationExecute' +type AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call struct { + *mock.Call +} + +// UpdateAlertConfigurationExecute is a helper method to define mock.On call +// - r admin.UpdateAlertConfigurationApiRequest +func (_e *AlertConfigurationsApi_Expecter) UpdateAlertConfigurationExecute(r interface{}) *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call { + return &AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call{Call: _e.mock.On("UpdateAlertConfigurationExecute", r)} +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call) Run(run func(r admin.UpdateAlertConfigurationApiRequest)) *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateAlertConfigurationApiRequest)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call) Return(_a0 *admin.GroupAlertsConfig, _a1 *http.Response, _a2 error) *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call) RunAndReturn(run func(admin.UpdateAlertConfigurationApiRequest) (*admin.GroupAlertsConfig, *http.Response, error)) *AlertConfigurationsApi_UpdateAlertConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAlertConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AlertConfigurationsApi) UpdateAlertConfigurationWithParams(ctx context.Context, args *admin.UpdateAlertConfigurationApiParams) admin.UpdateAlertConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateAlertConfigurationWithParams") + } + + var r0 admin.UpdateAlertConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateAlertConfigurationApiParams) admin.UpdateAlertConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateAlertConfigurationApiRequest) + } + + return r0 +} + +// AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAlertConfigurationWithParams' +type AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call struct { + *mock.Call +} + +// UpdateAlertConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateAlertConfigurationApiParams +func (_e *AlertConfigurationsApi_Expecter) UpdateAlertConfigurationWithParams(ctx interface{}, args interface{}) *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call { + return &AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call{Call: _e.mock.On("UpdateAlertConfigurationWithParams", ctx, args)} +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateAlertConfigurationApiParams)) *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateAlertConfigurationApiParams)) + }) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call) Return(_a0 admin.UpdateAlertConfigurationApiRequest) *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAlertConfigurationApiParams) admin.UpdateAlertConfigurationApiRequest) *AlertConfigurationsApi_UpdateAlertConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewAlertConfigurationsApi creates a new instance of AlertConfigurationsApi. 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 NewAlertConfigurationsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *AlertConfigurationsApi { + mock := &AlertConfigurationsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/alerts_api.go b/mockadmin/alerts_api.go new file mode 100644 index 000000000..403ae3f76 --- /dev/null +++ b/mockadmin/alerts_api.go @@ -0,0 +1,688 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// AlertsApi is an autogenerated mock type for the AlertsApi type +type AlertsApi struct { + mock.Mock +} + +type AlertsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *AlertsApi) EXPECT() *AlertsApi_Expecter { + return &AlertsApi_Expecter{mock: &_m.Mock} +} + +// AcknowledgeAlert provides a mock function with given fields: ctx, groupId, alertId, alertViewForNdsGroup +func (_m *AlertsApi) AcknowledgeAlert(ctx context.Context, groupId string, alertId string, alertViewForNdsGroup *admin.AlertViewForNdsGroup) admin.AcknowledgeAlertApiRequest { + ret := _m.Called(ctx, groupId, alertId, alertViewForNdsGroup) + + if len(ret) == 0 { + panic("no return value specified for AcknowledgeAlert") + } + + var r0 admin.AcknowledgeAlertApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.AlertViewForNdsGroup) admin.AcknowledgeAlertApiRequest); ok { + r0 = rf(ctx, groupId, alertId, alertViewForNdsGroup) + } else { + r0 = ret.Get(0).(admin.AcknowledgeAlertApiRequest) + } + + return r0 +} + +// AlertsApi_AcknowledgeAlert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcknowledgeAlert' +type AlertsApi_AcknowledgeAlert_Call struct { + *mock.Call +} + +// AcknowledgeAlert is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertId string +// - alertViewForNdsGroup *admin.AlertViewForNdsGroup +func (_e *AlertsApi_Expecter) AcknowledgeAlert(ctx interface{}, groupId interface{}, alertId interface{}, alertViewForNdsGroup interface{}) *AlertsApi_AcknowledgeAlert_Call { + return &AlertsApi_AcknowledgeAlert_Call{Call: _e.mock.On("AcknowledgeAlert", ctx, groupId, alertId, alertViewForNdsGroup)} +} + +func (_c *AlertsApi_AcknowledgeAlert_Call) Run(run func(ctx context.Context, groupId string, alertId string, alertViewForNdsGroup *admin.AlertViewForNdsGroup)) *AlertsApi_AcknowledgeAlert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.AlertViewForNdsGroup)) + }) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlert_Call) Return(_a0 admin.AcknowledgeAlertApiRequest) *AlertsApi_AcknowledgeAlert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlert_Call) RunAndReturn(run func(context.Context, string, string, *admin.AlertViewForNdsGroup) admin.AcknowledgeAlertApiRequest) *AlertsApi_AcknowledgeAlert_Call { + _c.Call.Return(run) + return _c +} + +// AcknowledgeAlertExecute provides a mock function with given fields: r +func (_m *AlertsApi) AcknowledgeAlertExecute(r admin.AcknowledgeAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for AcknowledgeAlertExecute") + } + + var r0 *admin.AlertViewForNdsGroup + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.AcknowledgeAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.AcknowledgeAlertApiRequest) *admin.AlertViewForNdsGroup); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AlertViewForNdsGroup) + } + } + + if rf, ok := ret.Get(1).(func(admin.AcknowledgeAlertApiRequest) *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.AcknowledgeAlertApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertsApi_AcknowledgeAlertExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcknowledgeAlertExecute' +type AlertsApi_AcknowledgeAlertExecute_Call struct { + *mock.Call +} + +// AcknowledgeAlertExecute is a helper method to define mock.On call +// - r admin.AcknowledgeAlertApiRequest +func (_e *AlertsApi_Expecter) AcknowledgeAlertExecute(r interface{}) *AlertsApi_AcknowledgeAlertExecute_Call { + return &AlertsApi_AcknowledgeAlertExecute_Call{Call: _e.mock.On("AcknowledgeAlertExecute", r)} +} + +func (_c *AlertsApi_AcknowledgeAlertExecute_Call) Run(run func(r admin.AcknowledgeAlertApiRequest)) *AlertsApi_AcknowledgeAlertExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.AcknowledgeAlertApiRequest)) + }) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlertExecute_Call) Return(_a0 *admin.AlertViewForNdsGroup, _a1 *http.Response, _a2 error) *AlertsApi_AcknowledgeAlertExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlertExecute_Call) RunAndReturn(run func(admin.AcknowledgeAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error)) *AlertsApi_AcknowledgeAlertExecute_Call { + _c.Call.Return(run) + return _c +} + +// AcknowledgeAlertWithParams provides a mock function with given fields: ctx, args +func (_m *AlertsApi) AcknowledgeAlertWithParams(ctx context.Context, args *admin.AcknowledgeAlertApiParams) admin.AcknowledgeAlertApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for AcknowledgeAlertWithParams") + } + + var r0 admin.AcknowledgeAlertApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.AcknowledgeAlertApiParams) admin.AcknowledgeAlertApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.AcknowledgeAlertApiRequest) + } + + return r0 +} + +// AlertsApi_AcknowledgeAlertWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcknowledgeAlertWithParams' +type AlertsApi_AcknowledgeAlertWithParams_Call struct { + *mock.Call +} + +// AcknowledgeAlertWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.AcknowledgeAlertApiParams +func (_e *AlertsApi_Expecter) AcknowledgeAlertWithParams(ctx interface{}, args interface{}) *AlertsApi_AcknowledgeAlertWithParams_Call { + return &AlertsApi_AcknowledgeAlertWithParams_Call{Call: _e.mock.On("AcknowledgeAlertWithParams", ctx, args)} +} + +func (_c *AlertsApi_AcknowledgeAlertWithParams_Call) Run(run func(ctx context.Context, args *admin.AcknowledgeAlertApiParams)) *AlertsApi_AcknowledgeAlertWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.AcknowledgeAlertApiParams)) + }) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlertWithParams_Call) Return(_a0 admin.AcknowledgeAlertApiRequest) *AlertsApi_AcknowledgeAlertWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_AcknowledgeAlertWithParams_Call) RunAndReturn(run func(context.Context, *admin.AcknowledgeAlertApiParams) admin.AcknowledgeAlertApiRequest) *AlertsApi_AcknowledgeAlertWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetAlert provides a mock function with given fields: ctx, groupId, alertId +func (_m *AlertsApi) GetAlert(ctx context.Context, groupId string, alertId string) admin.GetAlertApiRequest { + ret := _m.Called(ctx, groupId, alertId) + + if len(ret) == 0 { + panic("no return value specified for GetAlert") + } + + var r0 admin.GetAlertApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetAlertApiRequest); ok { + r0 = rf(ctx, groupId, alertId) + } else { + r0 = ret.Get(0).(admin.GetAlertApiRequest) + } + + return r0 +} + +// AlertsApi_GetAlert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlert' +type AlertsApi_GetAlert_Call struct { + *mock.Call +} + +// GetAlert is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertId string +func (_e *AlertsApi_Expecter) GetAlert(ctx interface{}, groupId interface{}, alertId interface{}) *AlertsApi_GetAlert_Call { + return &AlertsApi_GetAlert_Call{Call: _e.mock.On("GetAlert", ctx, groupId, alertId)} +} + +func (_c *AlertsApi_GetAlert_Call) Run(run func(ctx context.Context, groupId string, alertId string)) *AlertsApi_GetAlert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AlertsApi_GetAlert_Call) Return(_a0 admin.GetAlertApiRequest) *AlertsApi_GetAlert_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_GetAlert_Call) RunAndReturn(run func(context.Context, string, string) admin.GetAlertApiRequest) *AlertsApi_GetAlert_Call { + _c.Call.Return(run) + return _c +} + +// GetAlertExecute provides a mock function with given fields: r +func (_m *AlertsApi) GetAlertExecute(r admin.GetAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetAlertExecute") + } + + var r0 *admin.AlertViewForNdsGroup + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetAlertApiRequest) *admin.AlertViewForNdsGroup); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AlertViewForNdsGroup) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetAlertApiRequest) *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.GetAlertApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertsApi_GetAlertExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlertExecute' +type AlertsApi_GetAlertExecute_Call struct { + *mock.Call +} + +// GetAlertExecute is a helper method to define mock.On call +// - r admin.GetAlertApiRequest +func (_e *AlertsApi_Expecter) GetAlertExecute(r interface{}) *AlertsApi_GetAlertExecute_Call { + return &AlertsApi_GetAlertExecute_Call{Call: _e.mock.On("GetAlertExecute", r)} +} + +func (_c *AlertsApi_GetAlertExecute_Call) Run(run func(r admin.GetAlertApiRequest)) *AlertsApi_GetAlertExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetAlertApiRequest)) + }) + return _c +} + +func (_c *AlertsApi_GetAlertExecute_Call) Return(_a0 *admin.AlertViewForNdsGroup, _a1 *http.Response, _a2 error) *AlertsApi_GetAlertExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertsApi_GetAlertExecute_Call) RunAndReturn(run func(admin.GetAlertApiRequest) (*admin.AlertViewForNdsGroup, *http.Response, error)) *AlertsApi_GetAlertExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetAlertWithParams provides a mock function with given fields: ctx, args +func (_m *AlertsApi) GetAlertWithParams(ctx context.Context, args *admin.GetAlertApiParams) admin.GetAlertApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetAlertWithParams") + } + + var r0 admin.GetAlertApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAlertApiParams) admin.GetAlertApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetAlertApiRequest) + } + + return r0 +} + +// AlertsApi_GetAlertWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlertWithParams' +type AlertsApi_GetAlertWithParams_Call struct { + *mock.Call +} + +// GetAlertWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetAlertApiParams +func (_e *AlertsApi_Expecter) GetAlertWithParams(ctx interface{}, args interface{}) *AlertsApi_GetAlertWithParams_Call { + return &AlertsApi_GetAlertWithParams_Call{Call: _e.mock.On("GetAlertWithParams", ctx, args)} +} + +func (_c *AlertsApi_GetAlertWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAlertApiParams)) *AlertsApi_GetAlertWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetAlertApiParams)) + }) + return _c +} + +func (_c *AlertsApi_GetAlertWithParams_Call) Return(_a0 admin.GetAlertApiRequest) *AlertsApi_GetAlertWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_GetAlertWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAlertApiParams) admin.GetAlertApiRequest) *AlertsApi_GetAlertWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAlerts provides a mock function with given fields: ctx, groupId +func (_m *AlertsApi) ListAlerts(ctx context.Context, groupId string) admin.ListAlertsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListAlerts") + } + + var r0 admin.ListAlertsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListAlertsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListAlertsApiRequest) + } + + return r0 +} + +// AlertsApi_ListAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlerts' +type AlertsApi_ListAlerts_Call struct { + *mock.Call +} + +// ListAlerts is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *AlertsApi_Expecter) ListAlerts(ctx interface{}, groupId interface{}) *AlertsApi_ListAlerts_Call { + return &AlertsApi_ListAlerts_Call{Call: _e.mock.On("ListAlerts", ctx, groupId)} +} + +func (_c *AlertsApi_ListAlerts_Call) Run(run func(ctx context.Context, groupId string)) *AlertsApi_ListAlerts_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *AlertsApi_ListAlerts_Call) Return(_a0 admin.ListAlertsApiRequest) *AlertsApi_ListAlerts_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_ListAlerts_Call) RunAndReturn(run func(context.Context, string) admin.ListAlertsApiRequest) *AlertsApi_ListAlerts_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertsByAlertConfigurationId provides a mock function with given fields: ctx, groupId, alertConfigId +func (_m *AlertsApi) ListAlertsByAlertConfigurationId(ctx context.Context, groupId string, alertConfigId string) admin.ListAlertsByAlertConfigurationIdApiRequest { + ret := _m.Called(ctx, groupId, alertConfigId) + + if len(ret) == 0 { + panic("no return value specified for ListAlertsByAlertConfigurationId") + } + + var r0 admin.ListAlertsByAlertConfigurationIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListAlertsByAlertConfigurationIdApiRequest); ok { + r0 = rf(ctx, groupId, alertConfigId) + } else { + r0 = ret.Get(0).(admin.ListAlertsByAlertConfigurationIdApiRequest) + } + + return r0 +} + +// AlertsApi_ListAlertsByAlertConfigurationId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertsByAlertConfigurationId' +type AlertsApi_ListAlertsByAlertConfigurationId_Call struct { + *mock.Call +} + +// ListAlertsByAlertConfigurationId is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - alertConfigId string +func (_e *AlertsApi_Expecter) ListAlertsByAlertConfigurationId(ctx interface{}, groupId interface{}, alertConfigId interface{}) *AlertsApi_ListAlertsByAlertConfigurationId_Call { + return &AlertsApi_ListAlertsByAlertConfigurationId_Call{Call: _e.mock.On("ListAlertsByAlertConfigurationId", ctx, groupId, alertConfigId)} +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationId_Call) Run(run func(ctx context.Context, groupId string, alertConfigId string)) *AlertsApi_ListAlertsByAlertConfigurationId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationId_Call) Return(_a0 admin.ListAlertsByAlertConfigurationIdApiRequest) *AlertsApi_ListAlertsByAlertConfigurationId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationId_Call) RunAndReturn(run func(context.Context, string, string) admin.ListAlertsByAlertConfigurationIdApiRequest) *AlertsApi_ListAlertsByAlertConfigurationId_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertsByAlertConfigurationIdExecute provides a mock function with given fields: r +func (_m *AlertsApi) ListAlertsByAlertConfigurationIdExecute(r admin.ListAlertsByAlertConfigurationIdApiRequest) (*admin.PaginatedAlert, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAlertsByAlertConfigurationIdExecute") + } + + var r0 *admin.PaginatedAlert + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAlertsByAlertConfigurationIdApiRequest) (*admin.PaginatedAlert, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAlertsByAlertConfigurationIdApiRequest) *admin.PaginatedAlert); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedAlert) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAlertsByAlertConfigurationIdApiRequest) *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.ListAlertsByAlertConfigurationIdApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertsByAlertConfigurationIdExecute' +type AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call struct { + *mock.Call +} + +// ListAlertsByAlertConfigurationIdExecute is a helper method to define mock.On call +// - r admin.ListAlertsByAlertConfigurationIdApiRequest +func (_e *AlertsApi_Expecter) ListAlertsByAlertConfigurationIdExecute(r interface{}) *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call { + return &AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call{Call: _e.mock.On("ListAlertsByAlertConfigurationIdExecute", r)} +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call) Run(run func(r admin.ListAlertsByAlertConfigurationIdApiRequest)) *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAlertsByAlertConfigurationIdApiRequest)) + }) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call) Return(_a0 *admin.PaginatedAlert, _a1 *http.Response, _a2 error) *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call) RunAndReturn(run func(admin.ListAlertsByAlertConfigurationIdApiRequest) (*admin.PaginatedAlert, *http.Response, error)) *AlertsApi_ListAlertsByAlertConfigurationIdExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertsByAlertConfigurationIdWithParams provides a mock function with given fields: ctx, args +func (_m *AlertsApi) ListAlertsByAlertConfigurationIdWithParams(ctx context.Context, args *admin.ListAlertsByAlertConfigurationIdApiParams) admin.ListAlertsByAlertConfigurationIdApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAlertsByAlertConfigurationIdWithParams") + } + + var r0 admin.ListAlertsByAlertConfigurationIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAlertsByAlertConfigurationIdApiParams) admin.ListAlertsByAlertConfigurationIdApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAlertsByAlertConfigurationIdApiRequest) + } + + return r0 +} + +// AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertsByAlertConfigurationIdWithParams' +type AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call struct { + *mock.Call +} + +// ListAlertsByAlertConfigurationIdWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAlertsByAlertConfigurationIdApiParams +func (_e *AlertsApi_Expecter) ListAlertsByAlertConfigurationIdWithParams(ctx interface{}, args interface{}) *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call { + return &AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call{Call: _e.mock.On("ListAlertsByAlertConfigurationIdWithParams", ctx, args)} +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAlertsByAlertConfigurationIdApiParams)) *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAlertsByAlertConfigurationIdApiParams)) + }) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call) Return(_a0 admin.ListAlertsByAlertConfigurationIdApiRequest) *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAlertsByAlertConfigurationIdApiParams) admin.ListAlertsByAlertConfigurationIdApiRequest) *AlertsApi_ListAlertsByAlertConfigurationIdWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertsExecute provides a mock function with given fields: r +func (_m *AlertsApi) ListAlertsExecute(r admin.ListAlertsApiRequest) (*admin.PaginatedAlert, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAlertsExecute") + } + + var r0 *admin.PaginatedAlert + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAlertsApiRequest) (*admin.PaginatedAlert, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAlertsApiRequest) *admin.PaginatedAlert); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedAlert) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAlertsApiRequest) *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.ListAlertsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AlertsApi_ListAlertsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertsExecute' +type AlertsApi_ListAlertsExecute_Call struct { + *mock.Call +} + +// ListAlertsExecute is a helper method to define mock.On call +// - r admin.ListAlertsApiRequest +func (_e *AlertsApi_Expecter) ListAlertsExecute(r interface{}) *AlertsApi_ListAlertsExecute_Call { + return &AlertsApi_ListAlertsExecute_Call{Call: _e.mock.On("ListAlertsExecute", r)} +} + +func (_c *AlertsApi_ListAlertsExecute_Call) Run(run func(r admin.ListAlertsApiRequest)) *AlertsApi_ListAlertsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAlertsApiRequest)) + }) + return _c +} + +func (_c *AlertsApi_ListAlertsExecute_Call) Return(_a0 *admin.PaginatedAlert, _a1 *http.Response, _a2 error) *AlertsApi_ListAlertsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AlertsApi_ListAlertsExecute_Call) RunAndReturn(run func(admin.ListAlertsApiRequest) (*admin.PaginatedAlert, *http.Response, error)) *AlertsApi_ListAlertsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAlertsWithParams provides a mock function with given fields: ctx, args +func (_m *AlertsApi) ListAlertsWithParams(ctx context.Context, args *admin.ListAlertsApiParams) admin.ListAlertsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAlertsWithParams") + } + + var r0 admin.ListAlertsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAlertsApiParams) admin.ListAlertsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAlertsApiRequest) + } + + return r0 +} + +// AlertsApi_ListAlertsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlertsWithParams' +type AlertsApi_ListAlertsWithParams_Call struct { + *mock.Call +} + +// ListAlertsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAlertsApiParams +func (_e *AlertsApi_Expecter) ListAlertsWithParams(ctx interface{}, args interface{}) *AlertsApi_ListAlertsWithParams_Call { + return &AlertsApi_ListAlertsWithParams_Call{Call: _e.mock.On("ListAlertsWithParams", ctx, args)} +} + +func (_c *AlertsApi_ListAlertsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAlertsApiParams)) *AlertsApi_ListAlertsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAlertsApiParams)) + }) + return _c +} + +func (_c *AlertsApi_ListAlertsWithParams_Call) Return(_a0 admin.ListAlertsApiRequest) *AlertsApi_ListAlertsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AlertsApi_ListAlertsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAlertsApiParams) admin.ListAlertsApiRequest) *AlertsApi_ListAlertsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewAlertsApi creates a new instance of AlertsApi. 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 NewAlertsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *AlertsApi { + mock := &AlertsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/atlas_search_api.go b/mockadmin/atlas_search_api.go new file mode 100644 index 000000000..43212609d --- /dev/null +++ b/mockadmin/atlas_search_api.go @@ -0,0 +1,1498 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +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/mockadmin/auditing_api.go b/mockadmin/auditing_api.go new file mode 100644 index 000000000..1c755a08e --- /dev/null +++ b/mockadmin/auditing_api.go @@ -0,0 +1,363 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// AuditingApi is an autogenerated mock type for the AuditingApi type +type AuditingApi struct { + mock.Mock +} + +type AuditingApi_Expecter struct { + mock *mock.Mock +} + +func (_m *AuditingApi) EXPECT() *AuditingApi_Expecter { + return &AuditingApi_Expecter{mock: &_m.Mock} +} + +// GetAuditingConfiguration provides a mock function with given fields: ctx, groupId +func (_m *AuditingApi) GetAuditingConfiguration(ctx context.Context, groupId string) admin.GetAuditingConfigurationApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetAuditingConfiguration") + } + + var r0 admin.GetAuditingConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetAuditingConfigurationApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetAuditingConfigurationApiRequest) + } + + return r0 +} + +// AuditingApi_GetAuditingConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditingConfiguration' +type AuditingApi_GetAuditingConfiguration_Call struct { + *mock.Call +} + +// GetAuditingConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *AuditingApi_Expecter) GetAuditingConfiguration(ctx interface{}, groupId interface{}) *AuditingApi_GetAuditingConfiguration_Call { + return &AuditingApi_GetAuditingConfiguration_Call{Call: _e.mock.On("GetAuditingConfiguration", ctx, groupId)} +} + +func (_c *AuditingApi_GetAuditingConfiguration_Call) Run(run func(ctx context.Context, groupId string)) *AuditingApi_GetAuditingConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *AuditingApi_GetAuditingConfiguration_Call) Return(_a0 admin.GetAuditingConfigurationApiRequest) *AuditingApi_GetAuditingConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AuditingApi_GetAuditingConfiguration_Call) RunAndReturn(run func(context.Context, string) admin.GetAuditingConfigurationApiRequest) *AuditingApi_GetAuditingConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetAuditingConfigurationExecute provides a mock function with given fields: r +func (_m *AuditingApi) GetAuditingConfigurationExecute(r admin.GetAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetAuditingConfigurationExecute") + } + + var r0 *admin.AuditLog + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetAuditingConfigurationApiRequest) *admin.AuditLog); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AuditLog) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetAuditingConfigurationApiRequest) *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.GetAuditingConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AuditingApi_GetAuditingConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditingConfigurationExecute' +type AuditingApi_GetAuditingConfigurationExecute_Call struct { + *mock.Call +} + +// GetAuditingConfigurationExecute is a helper method to define mock.On call +// - r admin.GetAuditingConfigurationApiRequest +func (_e *AuditingApi_Expecter) GetAuditingConfigurationExecute(r interface{}) *AuditingApi_GetAuditingConfigurationExecute_Call { + return &AuditingApi_GetAuditingConfigurationExecute_Call{Call: _e.mock.On("GetAuditingConfigurationExecute", r)} +} + +func (_c *AuditingApi_GetAuditingConfigurationExecute_Call) Run(run func(r admin.GetAuditingConfigurationApiRequest)) *AuditingApi_GetAuditingConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetAuditingConfigurationApiRequest)) + }) + return _c +} + +func (_c *AuditingApi_GetAuditingConfigurationExecute_Call) Return(_a0 *admin.AuditLog, _a1 *http.Response, _a2 error) *AuditingApi_GetAuditingConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AuditingApi_GetAuditingConfigurationExecute_Call) RunAndReturn(run func(admin.GetAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error)) *AuditingApi_GetAuditingConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetAuditingConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AuditingApi) GetAuditingConfigurationWithParams(ctx context.Context, args *admin.GetAuditingConfigurationApiParams) admin.GetAuditingConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetAuditingConfigurationWithParams") + } + + var r0 admin.GetAuditingConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAuditingConfigurationApiParams) admin.GetAuditingConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetAuditingConfigurationApiRequest) + } + + return r0 +} + +// AuditingApi_GetAuditingConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditingConfigurationWithParams' +type AuditingApi_GetAuditingConfigurationWithParams_Call struct { + *mock.Call +} + +// GetAuditingConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetAuditingConfigurationApiParams +func (_e *AuditingApi_Expecter) GetAuditingConfigurationWithParams(ctx interface{}, args interface{}) *AuditingApi_GetAuditingConfigurationWithParams_Call { + return &AuditingApi_GetAuditingConfigurationWithParams_Call{Call: _e.mock.On("GetAuditingConfigurationWithParams", ctx, args)} +} + +func (_c *AuditingApi_GetAuditingConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAuditingConfigurationApiParams)) *AuditingApi_GetAuditingConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetAuditingConfigurationApiParams)) + }) + return _c +} + +func (_c *AuditingApi_GetAuditingConfigurationWithParams_Call) Return(_a0 admin.GetAuditingConfigurationApiRequest) *AuditingApi_GetAuditingConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AuditingApi_GetAuditingConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAuditingConfigurationApiParams) admin.GetAuditingConfigurationApiRequest) *AuditingApi_GetAuditingConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAuditingConfiguration provides a mock function with given fields: ctx, groupId, auditLog +func (_m *AuditingApi) UpdateAuditingConfiguration(ctx context.Context, groupId string, auditLog *admin.AuditLog) admin.UpdateAuditingConfigurationApiRequest { + ret := _m.Called(ctx, groupId, auditLog) + + if len(ret) == 0 { + panic("no return value specified for UpdateAuditingConfiguration") + } + + var r0 admin.UpdateAuditingConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.AuditLog) admin.UpdateAuditingConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, auditLog) + } else { + r0 = ret.Get(0).(admin.UpdateAuditingConfigurationApiRequest) + } + + return r0 +} + +// AuditingApi_UpdateAuditingConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAuditingConfiguration' +type AuditingApi_UpdateAuditingConfiguration_Call struct { + *mock.Call +} + +// UpdateAuditingConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - auditLog *admin.AuditLog +func (_e *AuditingApi_Expecter) UpdateAuditingConfiguration(ctx interface{}, groupId interface{}, auditLog interface{}) *AuditingApi_UpdateAuditingConfiguration_Call { + return &AuditingApi_UpdateAuditingConfiguration_Call{Call: _e.mock.On("UpdateAuditingConfiguration", ctx, groupId, auditLog)} +} + +func (_c *AuditingApi_UpdateAuditingConfiguration_Call) Run(run func(ctx context.Context, groupId string, auditLog *admin.AuditLog)) *AuditingApi_UpdateAuditingConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.AuditLog)) + }) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfiguration_Call) Return(_a0 admin.UpdateAuditingConfigurationApiRequest) *AuditingApi_UpdateAuditingConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.AuditLog) admin.UpdateAuditingConfigurationApiRequest) *AuditingApi_UpdateAuditingConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAuditingConfigurationExecute provides a mock function with given fields: r +func (_m *AuditingApi) UpdateAuditingConfigurationExecute(r admin.UpdateAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateAuditingConfigurationExecute") + } + + var r0 *admin.AuditLog + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateAuditingConfigurationApiRequest) *admin.AuditLog); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AuditLog) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateAuditingConfigurationApiRequest) *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.UpdateAuditingConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AuditingApi_UpdateAuditingConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAuditingConfigurationExecute' +type AuditingApi_UpdateAuditingConfigurationExecute_Call struct { + *mock.Call +} + +// UpdateAuditingConfigurationExecute is a helper method to define mock.On call +// - r admin.UpdateAuditingConfigurationApiRequest +func (_e *AuditingApi_Expecter) UpdateAuditingConfigurationExecute(r interface{}) *AuditingApi_UpdateAuditingConfigurationExecute_Call { + return &AuditingApi_UpdateAuditingConfigurationExecute_Call{Call: _e.mock.On("UpdateAuditingConfigurationExecute", r)} +} + +func (_c *AuditingApi_UpdateAuditingConfigurationExecute_Call) Run(run func(r admin.UpdateAuditingConfigurationApiRequest)) *AuditingApi_UpdateAuditingConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateAuditingConfigurationApiRequest)) + }) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfigurationExecute_Call) Return(_a0 *admin.AuditLog, _a1 *http.Response, _a2 error) *AuditingApi_UpdateAuditingConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfigurationExecute_Call) RunAndReturn(run func(admin.UpdateAuditingConfigurationApiRequest) (*admin.AuditLog, *http.Response, error)) *AuditingApi_UpdateAuditingConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateAuditingConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *AuditingApi) UpdateAuditingConfigurationWithParams(ctx context.Context, args *admin.UpdateAuditingConfigurationApiParams) admin.UpdateAuditingConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateAuditingConfigurationWithParams") + } + + var r0 admin.UpdateAuditingConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateAuditingConfigurationApiParams) admin.UpdateAuditingConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateAuditingConfigurationApiRequest) + } + + return r0 +} + +// AuditingApi_UpdateAuditingConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAuditingConfigurationWithParams' +type AuditingApi_UpdateAuditingConfigurationWithParams_Call struct { + *mock.Call +} + +// UpdateAuditingConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateAuditingConfigurationApiParams +func (_e *AuditingApi_Expecter) UpdateAuditingConfigurationWithParams(ctx interface{}, args interface{}) *AuditingApi_UpdateAuditingConfigurationWithParams_Call { + return &AuditingApi_UpdateAuditingConfigurationWithParams_Call{Call: _e.mock.On("UpdateAuditingConfigurationWithParams", ctx, args)} +} + +func (_c *AuditingApi_UpdateAuditingConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateAuditingConfigurationApiParams)) *AuditingApi_UpdateAuditingConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateAuditingConfigurationApiParams)) + }) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfigurationWithParams_Call) Return(_a0 admin.UpdateAuditingConfigurationApiRequest) *AuditingApi_UpdateAuditingConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AuditingApi_UpdateAuditingConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateAuditingConfigurationApiParams) admin.UpdateAuditingConfigurationApiRequest) *AuditingApi_UpdateAuditingConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewAuditingApi creates a new instance of AuditingApi. 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 NewAuditingApi(t interface { + mock.TestingT + Cleanup(func()) +}) *AuditingApi { + mock := &AuditingApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/aws_clusters_dns_api.go b/mockadmin/aws_clusters_dns_api.go new file mode 100644 index 000000000..2b33d7a83 --- /dev/null +++ b/mockadmin/aws_clusters_dns_api.go @@ -0,0 +1,363 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// AWSClustersDNSApi is an autogenerated mock type for the AWSClustersDNSApi type +type AWSClustersDNSApi struct { + mock.Mock +} + +type AWSClustersDNSApi_Expecter struct { + mock *mock.Mock +} + +func (_m *AWSClustersDNSApi) EXPECT() *AWSClustersDNSApi_Expecter { + return &AWSClustersDNSApi_Expecter{mock: &_m.Mock} +} + +// GetAWSCustomDNS provides a mock function with given fields: ctx, groupId +func (_m *AWSClustersDNSApi) GetAWSCustomDNS(ctx context.Context, groupId string) admin.GetAWSCustomDNSApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetAWSCustomDNS") + } + + var r0 admin.GetAWSCustomDNSApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetAWSCustomDNSApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetAWSCustomDNSApiRequest) + } + + return r0 +} + +// AWSClustersDNSApi_GetAWSCustomDNS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAWSCustomDNS' +type AWSClustersDNSApi_GetAWSCustomDNS_Call struct { + *mock.Call +} + +// GetAWSCustomDNS is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *AWSClustersDNSApi_Expecter) GetAWSCustomDNS(ctx interface{}, groupId interface{}) *AWSClustersDNSApi_GetAWSCustomDNS_Call { + return &AWSClustersDNSApi_GetAWSCustomDNS_Call{Call: _e.mock.On("GetAWSCustomDNS", ctx, groupId)} +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNS_Call) Run(run func(ctx context.Context, groupId string)) *AWSClustersDNSApi_GetAWSCustomDNS_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNS_Call) Return(_a0 admin.GetAWSCustomDNSApiRequest) *AWSClustersDNSApi_GetAWSCustomDNS_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNS_Call) RunAndReturn(run func(context.Context, string) admin.GetAWSCustomDNSApiRequest) *AWSClustersDNSApi_GetAWSCustomDNS_Call { + _c.Call.Return(run) + return _c +} + +// GetAWSCustomDNSExecute provides a mock function with given fields: r +func (_m *AWSClustersDNSApi) GetAWSCustomDNSExecute(r admin.GetAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetAWSCustomDNSExecute") + } + + var r0 *admin.AWSCustomDNSEnabled + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetAWSCustomDNSApiRequest) *admin.AWSCustomDNSEnabled); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AWSCustomDNSEnabled) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetAWSCustomDNSApiRequest) *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.GetAWSCustomDNSApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AWSClustersDNSApi_GetAWSCustomDNSExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAWSCustomDNSExecute' +type AWSClustersDNSApi_GetAWSCustomDNSExecute_Call struct { + *mock.Call +} + +// GetAWSCustomDNSExecute is a helper method to define mock.On call +// - r admin.GetAWSCustomDNSApiRequest +func (_e *AWSClustersDNSApi_Expecter) GetAWSCustomDNSExecute(r interface{}) *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call { + return &AWSClustersDNSApi_GetAWSCustomDNSExecute_Call{Call: _e.mock.On("GetAWSCustomDNSExecute", r)} +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call) Run(run func(r admin.GetAWSCustomDNSApiRequest)) *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetAWSCustomDNSApiRequest)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call) Return(_a0 *admin.AWSCustomDNSEnabled, _a1 *http.Response, _a2 error) *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call) RunAndReturn(run func(admin.GetAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error)) *AWSClustersDNSApi_GetAWSCustomDNSExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetAWSCustomDNSWithParams provides a mock function with given fields: ctx, args +func (_m *AWSClustersDNSApi) GetAWSCustomDNSWithParams(ctx context.Context, args *admin.GetAWSCustomDNSApiParams) admin.GetAWSCustomDNSApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetAWSCustomDNSWithParams") + } + + var r0 admin.GetAWSCustomDNSApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAWSCustomDNSApiParams) admin.GetAWSCustomDNSApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetAWSCustomDNSApiRequest) + } + + return r0 +} + +// AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAWSCustomDNSWithParams' +type AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call struct { + *mock.Call +} + +// GetAWSCustomDNSWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetAWSCustomDNSApiParams +func (_e *AWSClustersDNSApi_Expecter) GetAWSCustomDNSWithParams(ctx interface{}, args interface{}) *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call { + return &AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call{Call: _e.mock.On("GetAWSCustomDNSWithParams", ctx, args)} +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAWSCustomDNSApiParams)) *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetAWSCustomDNSApiParams)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call) Return(_a0 admin.GetAWSCustomDNSApiRequest) *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAWSCustomDNSApiParams) admin.GetAWSCustomDNSApiRequest) *AWSClustersDNSApi_GetAWSCustomDNSWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAWSCustomDNS provides a mock function with given fields: ctx, groupId, aWSCustomDNSEnabled +func (_m *AWSClustersDNSApi) ToggleAWSCustomDNS(ctx context.Context, groupId string, aWSCustomDNSEnabled *admin.AWSCustomDNSEnabled) admin.ToggleAWSCustomDNSApiRequest { + ret := _m.Called(ctx, groupId, aWSCustomDNSEnabled) + + if len(ret) == 0 { + panic("no return value specified for ToggleAWSCustomDNS") + } + + var r0 admin.ToggleAWSCustomDNSApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.AWSCustomDNSEnabled) admin.ToggleAWSCustomDNSApiRequest); ok { + r0 = rf(ctx, groupId, aWSCustomDNSEnabled) + } else { + r0 = ret.Get(0).(admin.ToggleAWSCustomDNSApiRequest) + } + + return r0 +} + +// AWSClustersDNSApi_ToggleAWSCustomDNS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAWSCustomDNS' +type AWSClustersDNSApi_ToggleAWSCustomDNS_Call struct { + *mock.Call +} + +// ToggleAWSCustomDNS is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - aWSCustomDNSEnabled *admin.AWSCustomDNSEnabled +func (_e *AWSClustersDNSApi_Expecter) ToggleAWSCustomDNS(ctx interface{}, groupId interface{}, aWSCustomDNSEnabled interface{}) *AWSClustersDNSApi_ToggleAWSCustomDNS_Call { + return &AWSClustersDNSApi_ToggleAWSCustomDNS_Call{Call: _e.mock.On("ToggleAWSCustomDNS", ctx, groupId, aWSCustomDNSEnabled)} +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNS_Call) Run(run func(ctx context.Context, groupId string, aWSCustomDNSEnabled *admin.AWSCustomDNSEnabled)) *AWSClustersDNSApi_ToggleAWSCustomDNS_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.AWSCustomDNSEnabled)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNS_Call) Return(_a0 admin.ToggleAWSCustomDNSApiRequest) *AWSClustersDNSApi_ToggleAWSCustomDNS_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNS_Call) RunAndReturn(run func(context.Context, string, *admin.AWSCustomDNSEnabled) admin.ToggleAWSCustomDNSApiRequest) *AWSClustersDNSApi_ToggleAWSCustomDNS_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAWSCustomDNSExecute provides a mock function with given fields: r +func (_m *AWSClustersDNSApi) ToggleAWSCustomDNSExecute(r admin.ToggleAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ToggleAWSCustomDNSExecute") + } + + var r0 *admin.AWSCustomDNSEnabled + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ToggleAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ToggleAWSCustomDNSApiRequest) *admin.AWSCustomDNSEnabled); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AWSCustomDNSEnabled) + } + } + + if rf, ok := ret.Get(1).(func(admin.ToggleAWSCustomDNSApiRequest) *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.ToggleAWSCustomDNSApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAWSCustomDNSExecute' +type AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call struct { + *mock.Call +} + +// ToggleAWSCustomDNSExecute is a helper method to define mock.On call +// - r admin.ToggleAWSCustomDNSApiRequest +func (_e *AWSClustersDNSApi_Expecter) ToggleAWSCustomDNSExecute(r interface{}) *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call { + return &AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call{Call: _e.mock.On("ToggleAWSCustomDNSExecute", r)} +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call) Run(run func(r admin.ToggleAWSCustomDNSApiRequest)) *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ToggleAWSCustomDNSApiRequest)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call) Return(_a0 *admin.AWSCustomDNSEnabled, _a1 *http.Response, _a2 error) *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call) RunAndReturn(run func(admin.ToggleAWSCustomDNSApiRequest) (*admin.AWSCustomDNSEnabled, *http.Response, error)) *AWSClustersDNSApi_ToggleAWSCustomDNSExecute_Call { + _c.Call.Return(run) + return _c +} + +// ToggleAWSCustomDNSWithParams provides a mock function with given fields: ctx, args +func (_m *AWSClustersDNSApi) ToggleAWSCustomDNSWithParams(ctx context.Context, args *admin.ToggleAWSCustomDNSApiParams) admin.ToggleAWSCustomDNSApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ToggleAWSCustomDNSWithParams") + } + + var r0 admin.ToggleAWSCustomDNSApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ToggleAWSCustomDNSApiParams) admin.ToggleAWSCustomDNSApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ToggleAWSCustomDNSApiRequest) + } + + return r0 +} + +// AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleAWSCustomDNSWithParams' +type AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call struct { + *mock.Call +} + +// ToggleAWSCustomDNSWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ToggleAWSCustomDNSApiParams +func (_e *AWSClustersDNSApi_Expecter) ToggleAWSCustomDNSWithParams(ctx interface{}, args interface{}) *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call { + return &AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call{Call: _e.mock.On("ToggleAWSCustomDNSWithParams", ctx, args)} +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call) Run(run func(ctx context.Context, args *admin.ToggleAWSCustomDNSApiParams)) *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ToggleAWSCustomDNSApiParams)) + }) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call) Return(_a0 admin.ToggleAWSCustomDNSApiRequest) *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call) RunAndReturn(run func(context.Context, *admin.ToggleAWSCustomDNSApiParams) admin.ToggleAWSCustomDNSApiRequest) *AWSClustersDNSApi_ToggleAWSCustomDNSWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewAWSClustersDNSApi creates a new instance of AWSClustersDNSApi. 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 NewAWSClustersDNSApi(t interface { + mock.TestingT + Cleanup(func()) +}) *AWSClustersDNSApi { + mock := &AWSClustersDNSApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/cloud_backups_api.go b/mockadmin/cloud_backups_api.go new file mode 100644 index 000000000..ff4fab5e0 --- /dev/null +++ b/mockadmin/cloud_backups_api.go @@ -0,0 +1,4752 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// CloudBackupsApi is an autogenerated mock type for the CloudBackupsApi type +type CloudBackupsApi struct { + mock.Mock +} + +type CloudBackupsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *CloudBackupsApi) EXPECT() *CloudBackupsApi_Expecter { + return &CloudBackupsApi_Expecter{mock: &_m.Mock} +} + +// CancelBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId +func (_m *CloudBackupsApi) CancelBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.CancelBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, restoreJobId) + + if len(ret) == 0 { + panic("no return value specified for CancelBackupRestoreJob") + } + + var r0 admin.CancelBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.CancelBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, restoreJobId) + } else { + r0 = ret.Get(0).(admin.CancelBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CancelBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelBackupRestoreJob' +type CloudBackupsApi_CancelBackupRestoreJob_Call struct { + *mock.Call +} + +// CancelBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - restoreJobId string +func (_e *CloudBackupsApi_Expecter) CancelBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, restoreJobId interface{}) *CloudBackupsApi_CancelBackupRestoreJob_Call { + return &CloudBackupsApi_CancelBackupRestoreJob_Call{Call: _e.mock.On("CancelBackupRestoreJob", ctx, groupId, clusterName, restoreJobId)} +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_CancelBackupRestoreJob_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 *CloudBackupsApi_CancelBackupRestoreJob_Call) Return(_a0 admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// CancelBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) CancelBackupRestoreJobExecute(r admin.CancelBackupRestoreJobApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CancelBackupRestoreJobExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CancelBackupRestoreJobApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CancelBackupRestoreJobApiRequest) 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.CancelBackupRestoreJobApiRequest) *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.CancelBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_CancelBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelBackupRestoreJobExecute' +type CloudBackupsApi_CancelBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// CancelBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.CancelBackupRestoreJobApiRequest +func (_e *CloudBackupsApi_Expecter) CancelBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CancelBackupRestoreJobExecute_Call { + return &CloudBackupsApi_CancelBackupRestoreJobExecute_Call{Call: _e.mock.On("CancelBackupRestoreJobExecute", r)} +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobExecute_Call) Run(run func(r admin.CancelBackupRestoreJobApiRequest)) *CloudBackupsApi_CancelBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CancelBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudBackupsApi_CancelBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CancelBackupRestoreJobApiRequest) (map[string]interface{}, *http.Response, error)) *CloudBackupsApi_CancelBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CancelBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) CancelBackupRestoreJobWithParams(ctx context.Context, args *admin.CancelBackupRestoreJobApiParams) admin.CancelBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CancelBackupRestoreJobWithParams") + } + + var r0 admin.CancelBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CancelBackupRestoreJobApiParams) admin.CancelBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CancelBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CancelBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelBackupRestoreJobWithParams' +type CloudBackupsApi_CancelBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// CancelBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CancelBackupRestoreJobApiParams +func (_e *CloudBackupsApi_Expecter) CancelBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call { + return &CloudBackupsApi_CancelBackupRestoreJobWithParams_Call{Call: _e.mock.On("CancelBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CancelBackupRestoreJobApiParams)) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CancelBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call) Return(_a0 admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CancelBackupRestoreJobApiParams) admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupExportJob provides a mock function with given fields: ctx, groupId, clusterName, diskBackupExportJobRequest +func (_m *CloudBackupsApi) CreateBackupExportJob(ctx context.Context, groupId string, clusterName string, diskBackupExportJobRequest *admin.DiskBackupExportJobRequest) admin.CreateBackupExportJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, diskBackupExportJobRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupExportJob") + } + + var r0 admin.CreateBackupExportJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DiskBackupExportJobRequest) admin.CreateBackupExportJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, diskBackupExportJobRequest) + } else { + r0 = ret.Get(0).(admin.CreateBackupExportJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateBackupExportJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupExportJob' +type CloudBackupsApi_CreateBackupExportJob_Call struct { + *mock.Call +} + +// CreateBackupExportJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - diskBackupExportJobRequest *admin.DiskBackupExportJobRequest +func (_e *CloudBackupsApi_Expecter) CreateBackupExportJob(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupExportJobRequest interface{}) *CloudBackupsApi_CreateBackupExportJob_Call { + return &CloudBackupsApi_CreateBackupExportJob_Call{Call: _e.mock.On("CreateBackupExportJob", ctx, groupId, clusterName, diskBackupExportJobRequest)} +} + +func (_c *CloudBackupsApi_CreateBackupExportJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, diskBackupExportJobRequest *admin.DiskBackupExportJobRequest)) *CloudBackupsApi_CreateBackupExportJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DiskBackupExportJobRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJob_Call) Return(_a0 admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupExportJobRequest) admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupExportJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) CreateBackupExportJobExecute(r admin.CreateBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupExportJobExecute") + } + + var r0 *admin.DiskBackupExportJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateBackupExportJobApiRequest) *admin.DiskBackupExportJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupExportJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateBackupExportJobApiRequest) *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.CreateBackupExportJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_CreateBackupExportJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupExportJobExecute' +type CloudBackupsApi_CreateBackupExportJobExecute_Call struct { + *mock.Call +} + +// CreateBackupExportJobExecute is a helper method to define mock.On call +// - r admin.CreateBackupExportJobApiRequest +func (_e *CloudBackupsApi_Expecter) CreateBackupExportJobExecute(r interface{}) *CloudBackupsApi_CreateBackupExportJobExecute_Call { + return &CloudBackupsApi_CreateBackupExportJobExecute_Call{Call: _e.mock.On("CreateBackupExportJobExecute", r)} +} + +func (_c *CloudBackupsApi_CreateBackupExportJobExecute_Call) Run(run func(r admin.CreateBackupExportJobApiRequest)) *CloudBackupsApi_CreateBackupExportJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateBackupExportJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJobExecute_Call) Return(_a0 *admin.DiskBackupExportJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_CreateBackupExportJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJobExecute_Call) RunAndReturn(run func(admin.CreateBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_CreateBackupExportJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupExportJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) CreateBackupExportJobWithParams(ctx context.Context, args *admin.CreateBackupExportJobApiParams) admin.CreateBackupExportJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupExportJobWithParams") + } + + var r0 admin.CreateBackupExportJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateBackupExportJobApiParams) admin.CreateBackupExportJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateBackupExportJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateBackupExportJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupExportJobWithParams' +type CloudBackupsApi_CreateBackupExportJobWithParams_Call struct { + *mock.Call +} + +// CreateBackupExportJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateBackupExportJobApiParams +func (_e *CloudBackupsApi_Expecter) CreateBackupExportJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateBackupExportJobWithParams_Call { + return &CloudBackupsApi_CreateBackupExportJobWithParams_Call{Call: _e.mock.On("CreateBackupExportJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_CreateBackupExportJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateBackupExportJobApiParams)) *CloudBackupsApi_CreateBackupExportJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateBackupExportJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJobWithParams_Call) Return(_a0 admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupExportJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateBackupExportJobApiParams) admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, diskBackupSnapshotRestoreJob +func (_m *CloudBackupsApi) CreateBackupRestoreJob(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotRestoreJob *admin.DiskBackupSnapshotRestoreJob) admin.CreateBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, diskBackupSnapshotRestoreJob) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupRestoreJob") + } + + var r0 admin.CreateBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DiskBackupSnapshotRestoreJob) admin.CreateBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, diskBackupSnapshotRestoreJob) + } else { + r0 = ret.Get(0).(admin.CreateBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupRestoreJob' +type CloudBackupsApi_CreateBackupRestoreJob_Call struct { + *mock.Call +} + +// CreateBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - diskBackupSnapshotRestoreJob *admin.DiskBackupSnapshotRestoreJob +func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupSnapshotRestoreJob interface{}) *CloudBackupsApi_CreateBackupRestoreJob_Call { + return &CloudBackupsApi_CreateBackupRestoreJob_Call{Call: _e.mock.On("CreateBackupRestoreJob", ctx, groupId, clusterName, diskBackupSnapshotRestoreJob)} +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotRestoreJob *admin.DiskBackupSnapshotRestoreJob)) *CloudBackupsApi_CreateBackupRestoreJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DiskBackupSnapshotRestoreJob)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJob_Call) Return(_a0 admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupSnapshotRestoreJob) admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) CreateBackupRestoreJobExecute(r admin.CreateBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupRestoreJobExecute") + } + + var r0 *admin.DiskBackupSnapshotRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateBackupRestoreJobApiRequest) *admin.DiskBackupSnapshotRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateBackupRestoreJobApiRequest) *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.CreateBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_CreateBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupRestoreJobExecute' +type CloudBackupsApi_CreateBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// CreateBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.CreateBackupRestoreJobApiRequest +func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call { + return &CloudBackupsApi_CreateBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateBackupRestoreJobExecute", r)} +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobExecute_Call) Run(run func(r admin.CreateBackupRestoreJobApiRequest)) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobExecute_Call) Return(_a0 *admin.DiskBackupSnapshotRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) CreateBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateBackupRestoreJobApiParams) admin.CreateBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateBackupRestoreJobWithParams") + } + + var r0 admin.CreateBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateBackupRestoreJobApiParams) admin.CreateBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBackupRestoreJobWithParams' +type CloudBackupsApi_CreateBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// CreateBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateBackupRestoreJobApiParams +func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call { + return &CloudBackupsApi_CreateBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateBackupRestoreJobApiParams)) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateBackupRestoreJobApiParams) admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateExportBucket provides a mock function with given fields: ctx, groupId, diskBackupSnapshotAWSExportBucket +func (_m *CloudBackupsApi) CreateExportBucket(ctx context.Context, groupId string, diskBackupSnapshotAWSExportBucket *admin.DiskBackupSnapshotAWSExportBucket) admin.CreateExportBucketApiRequest { + ret := _m.Called(ctx, groupId, diskBackupSnapshotAWSExportBucket) + + if len(ret) == 0 { + panic("no return value specified for CreateExportBucket") + } + + var r0 admin.CreateExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.DiskBackupSnapshotAWSExportBucket) admin.CreateExportBucketApiRequest); ok { + r0 = rf(ctx, groupId, diskBackupSnapshotAWSExportBucket) + } else { + r0 = ret.Get(0).(admin.CreateExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateExportBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateExportBucket' +type CloudBackupsApi_CreateExportBucket_Call struct { + *mock.Call +} + +// CreateExportBucket is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - diskBackupSnapshotAWSExportBucket *admin.DiskBackupSnapshotAWSExportBucket +func (_e *CloudBackupsApi_Expecter) CreateExportBucket(ctx interface{}, groupId interface{}, diskBackupSnapshotAWSExportBucket interface{}) *CloudBackupsApi_CreateExportBucket_Call { + return &CloudBackupsApi_CreateExportBucket_Call{Call: _e.mock.On("CreateExportBucket", ctx, groupId, diskBackupSnapshotAWSExportBucket)} +} + +func (_c *CloudBackupsApi_CreateExportBucket_Call) Run(run func(ctx context.Context, groupId string, diskBackupSnapshotAWSExportBucket *admin.DiskBackupSnapshotAWSExportBucket)) *CloudBackupsApi_CreateExportBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.DiskBackupSnapshotAWSExportBucket)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucket_Call) Return(_a0 admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucket_Call) RunAndReturn(run func(context.Context, string, *admin.DiskBackupSnapshotAWSExportBucket) admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucket_Call { + _c.Call.Return(run) + return _c +} + +// CreateExportBucketExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) CreateExportBucketExecute(r admin.CreateExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateExportBucketExecute") + } + + var r0 *admin.DiskBackupSnapshotAWSExportBucket + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateExportBucketApiRequest) *admin.DiskBackupSnapshotAWSExportBucket); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotAWSExportBucket) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateExportBucketApiRequest) *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.CreateExportBucketApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_CreateExportBucketExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateExportBucketExecute' +type CloudBackupsApi_CreateExportBucketExecute_Call struct { + *mock.Call +} + +// CreateExportBucketExecute is a helper method to define mock.On call +// - r admin.CreateExportBucketApiRequest +func (_e *CloudBackupsApi_Expecter) CreateExportBucketExecute(r interface{}) *CloudBackupsApi_CreateExportBucketExecute_Call { + return &CloudBackupsApi_CreateExportBucketExecute_Call{Call: _e.mock.On("CreateExportBucketExecute", r)} +} + +func (_c *CloudBackupsApi_CreateExportBucketExecute_Call) Run(run func(r admin.CreateExportBucketApiRequest)) *CloudBackupsApi_CreateExportBucketExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateExportBucketApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucketExecute_Call) Return(_a0 *admin.DiskBackupSnapshotAWSExportBucket, _a1 *http.Response, _a2 error) *CloudBackupsApi_CreateExportBucketExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucketExecute_Call) RunAndReturn(run func(admin.CreateExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)) *CloudBackupsApi_CreateExportBucketExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateExportBucketWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) CreateExportBucketWithParams(ctx context.Context, args *admin.CreateExportBucketApiParams) admin.CreateExportBucketApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateExportBucketWithParams") + } + + var r0 admin.CreateExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateExportBucketApiParams) admin.CreateExportBucketApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateExportBucketWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateExportBucketWithParams' +type CloudBackupsApi_CreateExportBucketWithParams_Call struct { + *mock.Call +} + +// CreateExportBucketWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateExportBucketApiParams +func (_e *CloudBackupsApi_Expecter) CreateExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateExportBucketWithParams_Call { + return &CloudBackupsApi_CreateExportBucketWithParams_Call{Call: _e.mock.On("CreateExportBucketWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_CreateExportBucketWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateExportBucketApiParams)) *CloudBackupsApi_CreateExportBucketWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateExportBucketApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucketWithParams_Call) Return(_a0 admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucketWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateExportBucketApiParams) admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucketWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, serverlessBackupRestoreJob +func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJob(ctx context.Context, groupId string, clusterName string, serverlessBackupRestoreJob *admin.ServerlessBackupRestoreJob) admin.CreateServerlessBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, serverlessBackupRestoreJob) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessBackupRestoreJob") + } + + var r0 admin.CreateServerlessBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ServerlessBackupRestoreJob) admin.CreateServerlessBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, serverlessBackupRestoreJob) + } else { + r0 = ret.Get(0).(admin.CreateServerlessBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateServerlessBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessBackupRestoreJob' +type CloudBackupsApi_CreateServerlessBackupRestoreJob_Call struct { + *mock.Call +} + +// CreateServerlessBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - serverlessBackupRestoreJob *admin.ServerlessBackupRestoreJob +func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, serverlessBackupRestoreJob interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call { + return &CloudBackupsApi_CreateServerlessBackupRestoreJob_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJob", ctx, groupId, clusterName, serverlessBackupRestoreJob)} +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, serverlessBackupRestoreJob *admin.ServerlessBackupRestoreJob)) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ServerlessBackupRestoreJob)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call) Return(_a0 admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.ServerlessBackupRestoreJob) admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJobExecute(r admin.CreateServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessBackupRestoreJobExecute") + } + + var r0 *admin.ServerlessBackupRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateServerlessBackupRestoreJobApiRequest) *admin.ServerlessBackupRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessBackupRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateServerlessBackupRestoreJobApiRequest) *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.CreateServerlessBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessBackupRestoreJobExecute' +type CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// CreateServerlessBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.CreateServerlessBackupRestoreJobApiRequest +func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call { + return &CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJobExecute", r)} +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call) Run(run func(r admin.CreateServerlessBackupRestoreJobApiRequest)) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateServerlessBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call) Return(_a0 *admin.ServerlessBackupRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateServerlessBackupRestoreJobApiParams) admin.CreateServerlessBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessBackupRestoreJobWithParams") + } + + var r0 admin.CreateServerlessBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateServerlessBackupRestoreJobApiParams) admin.CreateServerlessBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateServerlessBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessBackupRestoreJobWithParams' +type CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// CreateServerlessBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateServerlessBackupRestoreJobApiParams +func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call { + return &CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateServerlessBackupRestoreJobApiParams)) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateServerlessBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateServerlessBackupRestoreJobApiParams) admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllBackupSchedules provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) DeleteAllBackupSchedules(ctx context.Context, groupId string, clusterName string) admin.DeleteAllBackupSchedulesApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllBackupSchedules") + } + + var r0 admin.DeleteAllBackupSchedulesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteAllBackupSchedulesApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.DeleteAllBackupSchedulesApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteAllBackupSchedules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllBackupSchedules' +type CloudBackupsApi_DeleteAllBackupSchedules_Call struct { + *mock.Call +} + +// DeleteAllBackupSchedules is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) DeleteAllBackupSchedules(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_DeleteAllBackupSchedules_Call { + return &CloudBackupsApi_DeleteAllBackupSchedules_Call{Call: _e.mock.On("DeleteAllBackupSchedules", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedules_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_DeleteAllBackupSchedules_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedules_Call) Return(_a0 admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedules_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedules_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedules_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllBackupSchedulesExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) DeleteAllBackupSchedulesExecute(r admin.DeleteAllBackupSchedulesApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllBackupSchedulesExecute") + } + + var r0 *admin.DiskBackupSnapshotSchedule + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteAllBackupSchedulesApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteAllBackupSchedulesApiRequest) *admin.DiskBackupSnapshotSchedule); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotSchedule) + } + } + + if rf, ok := ret.Get(1).(func(admin.DeleteAllBackupSchedulesApiRequest) *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.DeleteAllBackupSchedulesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllBackupSchedulesExecute' +type CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call struct { + *mock.Call +} + +// DeleteAllBackupSchedulesExecute is a helper method to define mock.On call +// - r admin.DeleteAllBackupSchedulesApiRequest +func (_e *CloudBackupsApi_Expecter) DeleteAllBackupSchedulesExecute(r interface{}) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call { + return &CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call{Call: _e.mock.On("DeleteAllBackupSchedulesExecute", r)} +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call) Run(run func(r admin.DeleteAllBackupSchedulesApiRequest)) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteAllBackupSchedulesApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call) Return(_a0 *admin.DiskBackupSnapshotSchedule, _a1 *http.Response, _a2 error) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call) RunAndReturn(run func(admin.DeleteAllBackupSchedulesApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllBackupSchedulesWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) DeleteAllBackupSchedulesWithParams(ctx context.Context, args *admin.DeleteAllBackupSchedulesApiParams) admin.DeleteAllBackupSchedulesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllBackupSchedulesWithParams") + } + + var r0 admin.DeleteAllBackupSchedulesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteAllBackupSchedulesApiParams) admin.DeleteAllBackupSchedulesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteAllBackupSchedulesApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllBackupSchedulesWithParams' +type CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call struct { + *mock.Call +} + +// DeleteAllBackupSchedulesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteAllBackupSchedulesApiParams +func (_e *CloudBackupsApi_Expecter) DeleteAllBackupSchedulesWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call { + return &CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call{Call: _e.mock.On("DeleteAllBackupSchedulesWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteAllBackupSchedulesApiParams)) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteAllBackupSchedulesApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call) Return(_a0 admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAllBackupSchedulesApiParams) admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteExportBucket provides a mock function with given fields: ctx, groupId, exportBucketId +func (_m *CloudBackupsApi) DeleteExportBucket(ctx context.Context, groupId string, exportBucketId string) admin.DeleteExportBucketApiRequest { + ret := _m.Called(ctx, groupId, exportBucketId) + + if len(ret) == 0 { + panic("no return value specified for DeleteExportBucket") + } + + var r0 admin.DeleteExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteExportBucketApiRequest); ok { + r0 = rf(ctx, groupId, exportBucketId) + } else { + r0 = ret.Get(0).(admin.DeleteExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteExportBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExportBucket' +type CloudBackupsApi_DeleteExportBucket_Call struct { + *mock.Call +} + +// DeleteExportBucket is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - exportBucketId string +func (_e *CloudBackupsApi_Expecter) DeleteExportBucket(ctx interface{}, groupId interface{}, exportBucketId interface{}) *CloudBackupsApi_DeleteExportBucket_Call { + return &CloudBackupsApi_DeleteExportBucket_Call{Call: _e.mock.On("DeleteExportBucket", ctx, groupId, exportBucketId)} +} + +func (_c *CloudBackupsApi_DeleteExportBucket_Call) Run(run func(ctx context.Context, groupId string, exportBucketId string)) *CloudBackupsApi_DeleteExportBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucket_Call) Return(_a0 admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucket_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucket_Call { + _c.Call.Return(run) + return _c +} + +// DeleteExportBucketExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) DeleteExportBucketExecute(r admin.DeleteExportBucketApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteExportBucketExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteExportBucketApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteExportBucketApiRequest) 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.DeleteExportBucketApiRequest) *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.DeleteExportBucketApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_DeleteExportBucketExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExportBucketExecute' +type CloudBackupsApi_DeleteExportBucketExecute_Call struct { + *mock.Call +} + +// DeleteExportBucketExecute is a helper method to define mock.On call +// - r admin.DeleteExportBucketApiRequest +func (_e *CloudBackupsApi_Expecter) DeleteExportBucketExecute(r interface{}) *CloudBackupsApi_DeleteExportBucketExecute_Call { + return &CloudBackupsApi_DeleteExportBucketExecute_Call{Call: _e.mock.On("DeleteExportBucketExecute", r)} +} + +func (_c *CloudBackupsApi_DeleteExportBucketExecute_Call) Run(run func(r admin.DeleteExportBucketApiRequest)) *CloudBackupsApi_DeleteExportBucketExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteExportBucketApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucketExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudBackupsApi_DeleteExportBucketExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucketExecute_Call) RunAndReturn(run func(admin.DeleteExportBucketApiRequest) (map[string]interface{}, *http.Response, error)) *CloudBackupsApi_DeleteExportBucketExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteExportBucketWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) DeleteExportBucketWithParams(ctx context.Context, args *admin.DeleteExportBucketApiParams) admin.DeleteExportBucketApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteExportBucketWithParams") + } + + var r0 admin.DeleteExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteExportBucketApiParams) admin.DeleteExportBucketApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteExportBucketWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExportBucketWithParams' +type CloudBackupsApi_DeleteExportBucketWithParams_Call struct { + *mock.Call +} + +// DeleteExportBucketWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteExportBucketApiParams +func (_e *CloudBackupsApi_Expecter) DeleteExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteExportBucketWithParams_Call { + return &CloudBackupsApi_DeleteExportBucketWithParams_Call{Call: _e.mock.On("DeleteExportBucketWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_DeleteExportBucketWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteExportBucketApiParams)) *CloudBackupsApi_DeleteExportBucketWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteExportBucketApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucketWithParams_Call) Return(_a0 admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucketWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteExportBucketApiParams) admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucketWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteReplicaSetBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *CloudBackupsApi) DeleteReplicaSetBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.DeleteReplicaSetBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for DeleteReplicaSetBackup") + } + + var r0 admin.DeleteReplicaSetBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteReplicaSetBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.DeleteReplicaSetBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteReplicaSetBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReplicaSetBackup' +type CloudBackupsApi_DeleteReplicaSetBackup_Call struct { + *mock.Call +} + +// DeleteReplicaSetBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *CloudBackupsApi_Expecter) DeleteReplicaSetBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *CloudBackupsApi_DeleteReplicaSetBackup_Call { + return &CloudBackupsApi_DeleteReplicaSetBackup_Call{Call: _e.mock.On("DeleteReplicaSetBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_DeleteReplicaSetBackup_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 *CloudBackupsApi_DeleteReplicaSetBackup_Call) Return(_a0 admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackup_Call { + _c.Call.Return(run) + return _c +} + +// DeleteReplicaSetBackupExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) DeleteReplicaSetBackupExecute(r admin.DeleteReplicaSetBackupApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteReplicaSetBackupExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteReplicaSetBackupApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteReplicaSetBackupApiRequest) 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.DeleteReplicaSetBackupApiRequest) *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.DeleteReplicaSetBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_DeleteReplicaSetBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReplicaSetBackupExecute' +type CloudBackupsApi_DeleteReplicaSetBackupExecute_Call struct { + *mock.Call +} + +// DeleteReplicaSetBackupExecute is a helper method to define mock.On call +// - r admin.DeleteReplicaSetBackupApiRequest +func (_e *CloudBackupsApi_Expecter) DeleteReplicaSetBackupExecute(r interface{}) *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call { + return &CloudBackupsApi_DeleteReplicaSetBackupExecute_Call{Call: _e.mock.On("DeleteReplicaSetBackupExecute", r)} +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call) Run(run func(r admin.DeleteReplicaSetBackupApiRequest)) *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteReplicaSetBackupApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call) RunAndReturn(run func(admin.DeleteReplicaSetBackupApiRequest) (map[string]interface{}, *http.Response, error)) *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteReplicaSetBackupWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) DeleteReplicaSetBackupWithParams(ctx context.Context, args *admin.DeleteReplicaSetBackupApiParams) admin.DeleteReplicaSetBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteReplicaSetBackupWithParams") + } + + var r0 admin.DeleteReplicaSetBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteReplicaSetBackupApiParams) admin.DeleteReplicaSetBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteReplicaSetBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReplicaSetBackupWithParams' +type CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call struct { + *mock.Call +} + +// DeleteReplicaSetBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteReplicaSetBackupApiParams +func (_e *CloudBackupsApi_Expecter) DeleteReplicaSetBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call { + return &CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call{Call: _e.mock.On("DeleteReplicaSetBackupWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteReplicaSetBackupApiParams)) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteReplicaSetBackupApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call) Return(_a0 admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteReplicaSetBackupApiParams) admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteShardedClusterBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *CloudBackupsApi) DeleteShardedClusterBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.DeleteShardedClusterBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for DeleteShardedClusterBackup") + } + + var r0 admin.DeleteShardedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteShardedClusterBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.DeleteShardedClusterBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteShardedClusterBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteShardedClusterBackup' +type CloudBackupsApi_DeleteShardedClusterBackup_Call struct { + *mock.Call +} + +// DeleteShardedClusterBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *CloudBackupsApi_Expecter) DeleteShardedClusterBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *CloudBackupsApi_DeleteShardedClusterBackup_Call { + return &CloudBackupsApi_DeleteShardedClusterBackup_Call{Call: _e.mock.On("DeleteShardedClusterBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_DeleteShardedClusterBackup_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 *CloudBackupsApi_DeleteShardedClusterBackup_Call) Return(_a0 admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackup_Call { + _c.Call.Return(run) + return _c +} + +// DeleteShardedClusterBackupExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) DeleteShardedClusterBackupExecute(r admin.DeleteShardedClusterBackupApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteShardedClusterBackupExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteShardedClusterBackupApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteShardedClusterBackupApiRequest) 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.DeleteShardedClusterBackupApiRequest) *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.DeleteShardedClusterBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_DeleteShardedClusterBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteShardedClusterBackupExecute' +type CloudBackupsApi_DeleteShardedClusterBackupExecute_Call struct { + *mock.Call +} + +// DeleteShardedClusterBackupExecute is a helper method to define mock.On call +// - r admin.DeleteShardedClusterBackupApiRequest +func (_e *CloudBackupsApi_Expecter) DeleteShardedClusterBackupExecute(r interface{}) *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call { + return &CloudBackupsApi_DeleteShardedClusterBackupExecute_Call{Call: _e.mock.On("DeleteShardedClusterBackupExecute", r)} +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call) Run(run func(r admin.DeleteShardedClusterBackupApiRequest)) *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteShardedClusterBackupApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call) RunAndReturn(run func(admin.DeleteShardedClusterBackupApiRequest) (map[string]interface{}, *http.Response, error)) *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteShardedClusterBackupWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) DeleteShardedClusterBackupWithParams(ctx context.Context, args *admin.DeleteShardedClusterBackupApiParams) admin.DeleteShardedClusterBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteShardedClusterBackupWithParams") + } + + var r0 admin.DeleteShardedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteShardedClusterBackupApiParams) admin.DeleteShardedClusterBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteShardedClusterBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteShardedClusterBackupWithParams' +type CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call struct { + *mock.Call +} + +// DeleteShardedClusterBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteShardedClusterBackupApiParams +func (_e *CloudBackupsApi_Expecter) DeleteShardedClusterBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call { + return &CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call{Call: _e.mock.On("DeleteShardedClusterBackupWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteShardedClusterBackupApiParams)) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteShardedClusterBackupApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call) Return(_a0 admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteShardedClusterBackupApiParams) admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupExportJob provides a mock function with given fields: ctx, groupId, clusterName, exportId +func (_m *CloudBackupsApi) GetBackupExportJob(ctx context.Context, groupId string, clusterName string, exportId string) admin.GetBackupExportJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, exportId) + + if len(ret) == 0 { + panic("no return value specified for GetBackupExportJob") + } + + var r0 admin.GetBackupExportJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetBackupExportJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, exportId) + } else { + r0 = ret.Get(0).(admin.GetBackupExportJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupExportJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupExportJob' +type CloudBackupsApi_GetBackupExportJob_Call struct { + *mock.Call +} + +// GetBackupExportJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - exportId string +func (_e *CloudBackupsApi_Expecter) GetBackupExportJob(ctx interface{}, groupId interface{}, clusterName interface{}, exportId interface{}) *CloudBackupsApi_GetBackupExportJob_Call { + return &CloudBackupsApi_GetBackupExportJob_Call{Call: _e.mock.On("GetBackupExportJob", ctx, groupId, clusterName, exportId)} +} + +func (_c *CloudBackupsApi_GetBackupExportJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, exportId string)) *CloudBackupsApi_GetBackupExportJob_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 *CloudBackupsApi_GetBackupExportJob_Call) Return(_a0 admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupExportJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJob_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupExportJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetBackupExportJobExecute(r admin.GetBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetBackupExportJobExecute") + } + + var r0 *admin.DiskBackupExportJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetBackupExportJobApiRequest) *admin.DiskBackupExportJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupExportJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetBackupExportJobApiRequest) *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.GetBackupExportJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetBackupExportJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupExportJobExecute' +type CloudBackupsApi_GetBackupExportJobExecute_Call struct { + *mock.Call +} + +// GetBackupExportJobExecute is a helper method to define mock.On call +// - r admin.GetBackupExportJobApiRequest +func (_e *CloudBackupsApi_Expecter) GetBackupExportJobExecute(r interface{}) *CloudBackupsApi_GetBackupExportJobExecute_Call { + return &CloudBackupsApi_GetBackupExportJobExecute_Call{Call: _e.mock.On("GetBackupExportJobExecute", r)} +} + +func (_c *CloudBackupsApi_GetBackupExportJobExecute_Call) Run(run func(r admin.GetBackupExportJobApiRequest)) *CloudBackupsApi_GetBackupExportJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetBackupExportJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupExportJobExecute_Call) Return(_a0 *admin.DiskBackupExportJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetBackupExportJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetBackupExportJobExecute_Call) RunAndReturn(run func(admin.GetBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_GetBackupExportJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupExportJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetBackupExportJobWithParams(ctx context.Context, args *admin.GetBackupExportJobApiParams) admin.GetBackupExportJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetBackupExportJobWithParams") + } + + var r0 admin.GetBackupExportJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetBackupExportJobApiParams) admin.GetBackupExportJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetBackupExportJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupExportJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupExportJobWithParams' +type CloudBackupsApi_GetBackupExportJobWithParams_Call struct { + *mock.Call +} + +// GetBackupExportJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetBackupExportJobApiParams +func (_e *CloudBackupsApi_Expecter) GetBackupExportJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupExportJobWithParams_Call { + return &CloudBackupsApi_GetBackupExportJobWithParams_Call{Call: _e.mock.On("GetBackupExportJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetBackupExportJobWithParams_Call) Run(run func(ctx context.Context, args *admin.GetBackupExportJobApiParams)) *CloudBackupsApi_GetBackupExportJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetBackupExportJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupExportJobWithParams_Call) Return(_a0 admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupExportJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupExportJobApiParams) admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId +func (_m *CloudBackupsApi) GetBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.GetBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, restoreJobId) + + if len(ret) == 0 { + panic("no return value specified for GetBackupRestoreJob") + } + + var r0 admin.GetBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, restoreJobId) + } else { + r0 = ret.Get(0).(admin.GetBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupRestoreJob' +type CloudBackupsApi_GetBackupRestoreJob_Call struct { + *mock.Call +} + +// GetBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - restoreJobId string +func (_e *CloudBackupsApi_Expecter) GetBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, restoreJobId interface{}) *CloudBackupsApi_GetBackupRestoreJob_Call { + return &CloudBackupsApi_GetBackupRestoreJob_Call{Call: _e.mock.On("GetBackupRestoreJob", ctx, groupId, clusterName, restoreJobId)} +} + +func (_c *CloudBackupsApi_GetBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_GetBackupRestoreJob_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 *CloudBackupsApi_GetBackupRestoreJob_Call) Return(_a0 admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetBackupRestoreJobExecute(r admin.GetBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetBackupRestoreJobExecute") + } + + var r0 *admin.DiskBackupSnapshotRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetBackupRestoreJobApiRequest) *admin.DiskBackupSnapshotRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetBackupRestoreJobApiRequest) *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.GetBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupRestoreJobExecute' +type CloudBackupsApi_GetBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// GetBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.GetBackupRestoreJobApiRequest +func (_e *CloudBackupsApi_Expecter) GetBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_GetBackupRestoreJobExecute_Call { + return &CloudBackupsApi_GetBackupRestoreJobExecute_Call{Call: _e.mock.On("GetBackupRestoreJobExecute", r)} +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobExecute_Call) Run(run func(r admin.GetBackupRestoreJobApiRequest)) *CloudBackupsApi_GetBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobExecute_Call) Return(_a0 *admin.DiskBackupSnapshotRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)) *CloudBackupsApi_GetBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetBackupRestoreJobWithParams(ctx context.Context, args *admin.GetBackupRestoreJobApiParams) admin.GetBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetBackupRestoreJobWithParams") + } + + var r0 admin.GetBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetBackupRestoreJobApiParams) admin.GetBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupRestoreJobWithParams' +type CloudBackupsApi_GetBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// GetBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetBackupRestoreJobApiParams +func (_e *CloudBackupsApi_Expecter) GetBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call { + return &CloudBackupsApi_GetBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.GetBackupRestoreJobApiParams)) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobWithParams_Call) Return(_a0 admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupRestoreJobApiParams) admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupSchedule provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) GetBackupSchedule(ctx context.Context, groupId string, clusterName string) admin.GetBackupScheduleApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetBackupSchedule") + } + + var r0 admin.GetBackupScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetBackupScheduleApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetBackupScheduleApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupSchedule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupSchedule' +type CloudBackupsApi_GetBackupSchedule_Call struct { + *mock.Call +} + +// GetBackupSchedule is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) GetBackupSchedule(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_GetBackupSchedule_Call { + return &CloudBackupsApi_GetBackupSchedule_Call{Call: _e.mock.On("GetBackupSchedule", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_GetBackupSchedule_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_GetBackupSchedule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupSchedule_Call) Return(_a0 admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupSchedule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupSchedule_Call) RunAndReturn(run func(context.Context, string, string) admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupSchedule_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupScheduleExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetBackupScheduleExecute(r admin.GetBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetBackupScheduleExecute") + } + + var r0 *admin.DiskBackupSnapshotSchedule + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetBackupScheduleApiRequest) *admin.DiskBackupSnapshotSchedule); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotSchedule) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetBackupScheduleApiRequest) *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.GetBackupScheduleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetBackupScheduleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupScheduleExecute' +type CloudBackupsApi_GetBackupScheduleExecute_Call struct { + *mock.Call +} + +// GetBackupScheduleExecute is a helper method to define mock.On call +// - r admin.GetBackupScheduleApiRequest +func (_e *CloudBackupsApi_Expecter) GetBackupScheduleExecute(r interface{}) *CloudBackupsApi_GetBackupScheduleExecute_Call { + return &CloudBackupsApi_GetBackupScheduleExecute_Call{Call: _e.mock.On("GetBackupScheduleExecute", r)} +} + +func (_c *CloudBackupsApi_GetBackupScheduleExecute_Call) Run(run func(r admin.GetBackupScheduleApiRequest)) *CloudBackupsApi_GetBackupScheduleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetBackupScheduleApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupScheduleExecute_Call) Return(_a0 *admin.DiskBackupSnapshotSchedule, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetBackupScheduleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetBackupScheduleExecute_Call) RunAndReturn(run func(admin.GetBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_GetBackupScheduleExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetBackupScheduleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetBackupScheduleWithParams(ctx context.Context, args *admin.GetBackupScheduleApiParams) admin.GetBackupScheduleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetBackupScheduleWithParams") + } + + var r0 admin.GetBackupScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetBackupScheduleApiParams) admin.GetBackupScheduleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetBackupScheduleApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetBackupScheduleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBackupScheduleWithParams' +type CloudBackupsApi_GetBackupScheduleWithParams_Call struct { + *mock.Call +} + +// GetBackupScheduleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetBackupScheduleApiParams +func (_e *CloudBackupsApi_Expecter) GetBackupScheduleWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupScheduleWithParams_Call { + return &CloudBackupsApi_GetBackupScheduleWithParams_Call{Call: _e.mock.On("GetBackupScheduleWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetBackupScheduleWithParams_Call) Run(run func(ctx context.Context, args *admin.GetBackupScheduleApiParams)) *CloudBackupsApi_GetBackupScheduleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetBackupScheduleApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetBackupScheduleWithParams_Call) Return(_a0 admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupScheduleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetBackupScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupScheduleApiParams) admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupScheduleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDataProtectionSettings provides a mock function with given fields: ctx, groupId +func (_m *CloudBackupsApi) GetDataProtectionSettings(ctx context.Context, groupId string) admin.GetDataProtectionSettingsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetDataProtectionSettings") + } + + var r0 admin.GetDataProtectionSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetDataProtectionSettingsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetDataProtectionSettingsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetDataProtectionSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataProtectionSettings' +type CloudBackupsApi_GetDataProtectionSettings_Call struct { + *mock.Call +} + +// GetDataProtectionSettings is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *CloudBackupsApi_Expecter) GetDataProtectionSettings(ctx interface{}, groupId interface{}) *CloudBackupsApi_GetDataProtectionSettings_Call { + return &CloudBackupsApi_GetDataProtectionSettings_Call{Call: _e.mock.On("GetDataProtectionSettings", ctx, groupId)} +} + +func (_c *CloudBackupsApi_GetDataProtectionSettings_Call) Run(run func(ctx context.Context, groupId string)) *CloudBackupsApi_GetDataProtectionSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettings_Call) Return(_a0 admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettings_Call) RunAndReturn(run func(context.Context, string) admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettings_Call { + _c.Call.Return(run) + return _c +} + +// GetDataProtectionSettingsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetDataProtectionSettingsExecute(r admin.GetDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDataProtectionSettingsExecute") + } + + var r0 *admin.DataProtectionSettings20231001 + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDataProtectionSettingsApiRequest) *admin.DataProtectionSettings20231001); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataProtectionSettings20231001) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDataProtectionSettingsApiRequest) *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.GetDataProtectionSettingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetDataProtectionSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataProtectionSettingsExecute' +type CloudBackupsApi_GetDataProtectionSettingsExecute_Call struct { + *mock.Call +} + +// GetDataProtectionSettingsExecute is a helper method to define mock.On call +// - r admin.GetDataProtectionSettingsApiRequest +func (_e *CloudBackupsApi_Expecter) GetDataProtectionSettingsExecute(r interface{}) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call { + return &CloudBackupsApi_GetDataProtectionSettingsExecute_Call{Call: _e.mock.On("GetDataProtectionSettingsExecute", r)} +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsExecute_Call) Run(run func(r admin.GetDataProtectionSettingsApiRequest)) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDataProtectionSettingsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsExecute_Call) Return(_a0 *admin.DataProtectionSettings20231001, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsExecute_Call) RunAndReturn(run func(admin.GetDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDataProtectionSettingsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetDataProtectionSettingsWithParams(ctx context.Context, args *admin.GetDataProtectionSettingsApiParams) admin.GetDataProtectionSettingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDataProtectionSettingsWithParams") + } + + var r0 admin.GetDataProtectionSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDataProtectionSettingsApiParams) admin.GetDataProtectionSettingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDataProtectionSettingsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetDataProtectionSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataProtectionSettingsWithParams' +type CloudBackupsApi_GetDataProtectionSettingsWithParams_Call struct { + *mock.Call +} + +// GetDataProtectionSettingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDataProtectionSettingsApiParams +func (_e *CloudBackupsApi_Expecter) GetDataProtectionSettingsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call { + return &CloudBackupsApi_GetDataProtectionSettingsWithParams_Call{Call: _e.mock.On("GetDataProtectionSettingsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDataProtectionSettingsApiParams)) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDataProtectionSettingsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call) Return(_a0 admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDataProtectionSettingsApiParams) admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetExportBucket provides a mock function with given fields: ctx, groupId, exportBucketId +func (_m *CloudBackupsApi) GetExportBucket(ctx context.Context, groupId string, exportBucketId string) admin.GetExportBucketApiRequest { + ret := _m.Called(ctx, groupId, exportBucketId) + + if len(ret) == 0 { + panic("no return value specified for GetExportBucket") + } + + var r0 admin.GetExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetExportBucketApiRequest); ok { + r0 = rf(ctx, groupId, exportBucketId) + } else { + r0 = ret.Get(0).(admin.GetExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetExportBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExportBucket' +type CloudBackupsApi_GetExportBucket_Call struct { + *mock.Call +} + +// GetExportBucket is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - exportBucketId string +func (_e *CloudBackupsApi_Expecter) GetExportBucket(ctx interface{}, groupId interface{}, exportBucketId interface{}) *CloudBackupsApi_GetExportBucket_Call { + return &CloudBackupsApi_GetExportBucket_Call{Call: _e.mock.On("GetExportBucket", ctx, groupId, exportBucketId)} +} + +func (_c *CloudBackupsApi_GetExportBucket_Call) Run(run func(ctx context.Context, groupId string, exportBucketId string)) *CloudBackupsApi_GetExportBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucket_Call) Return(_a0 admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucket_Call) RunAndReturn(run func(context.Context, string, string) admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucket_Call { + _c.Call.Return(run) + return _c +} + +// GetExportBucketExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetExportBucketExecute(r admin.GetExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetExportBucketExecute") + } + + var r0 *admin.DiskBackupSnapshotAWSExportBucket + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetExportBucketApiRequest) *admin.DiskBackupSnapshotAWSExportBucket); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotAWSExportBucket) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetExportBucketApiRequest) *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.GetExportBucketApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetExportBucketExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExportBucketExecute' +type CloudBackupsApi_GetExportBucketExecute_Call struct { + *mock.Call +} + +// GetExportBucketExecute is a helper method to define mock.On call +// - r admin.GetExportBucketApiRequest +func (_e *CloudBackupsApi_Expecter) GetExportBucketExecute(r interface{}) *CloudBackupsApi_GetExportBucketExecute_Call { + return &CloudBackupsApi_GetExportBucketExecute_Call{Call: _e.mock.On("GetExportBucketExecute", r)} +} + +func (_c *CloudBackupsApi_GetExportBucketExecute_Call) Run(run func(r admin.GetExportBucketApiRequest)) *CloudBackupsApi_GetExportBucketExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetExportBucketApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucketExecute_Call) Return(_a0 *admin.DiskBackupSnapshotAWSExportBucket, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetExportBucketExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucketExecute_Call) RunAndReturn(run func(admin.GetExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)) *CloudBackupsApi_GetExportBucketExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetExportBucketWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetExportBucketWithParams(ctx context.Context, args *admin.GetExportBucketApiParams) admin.GetExportBucketApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetExportBucketWithParams") + } + + var r0 admin.GetExportBucketApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetExportBucketApiParams) admin.GetExportBucketApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetExportBucketApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetExportBucketWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExportBucketWithParams' +type CloudBackupsApi_GetExportBucketWithParams_Call struct { + *mock.Call +} + +// GetExportBucketWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetExportBucketApiParams +func (_e *CloudBackupsApi_Expecter) GetExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetExportBucketWithParams_Call { + return &CloudBackupsApi_GetExportBucketWithParams_Call{Call: _e.mock.On("GetExportBucketWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetExportBucketWithParams_Call) Run(run func(ctx context.Context, args *admin.GetExportBucketApiParams)) *CloudBackupsApi_GetExportBucketWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetExportBucketApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucketWithParams_Call) Return(_a0 admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucketWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetExportBucketApiParams) admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucketWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetReplicaSetBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *CloudBackupsApi) GetReplicaSetBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetReplicaSetBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for GetReplicaSetBackup") + } + + var r0 admin.GetReplicaSetBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetReplicaSetBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.GetReplicaSetBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetReplicaSetBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicaSetBackup' +type CloudBackupsApi_GetReplicaSetBackup_Call struct { + *mock.Call +} + +// GetReplicaSetBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *CloudBackupsApi_Expecter) GetReplicaSetBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *CloudBackupsApi_GetReplicaSetBackup_Call { + return &CloudBackupsApi_GetReplicaSetBackup_Call{Call: _e.mock.On("GetReplicaSetBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *CloudBackupsApi_GetReplicaSetBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetReplicaSetBackup_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 *CloudBackupsApi_GetReplicaSetBackup_Call) Return(_a0 admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetReplicaSetBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackup_Call { + _c.Call.Return(run) + return _c +} + +// GetReplicaSetBackupExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetReplicaSetBackupExecute(r admin.GetReplicaSetBackupApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetReplicaSetBackupExecute") + } + + var r0 *admin.DiskBackupReplicaSet + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetReplicaSetBackupApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetReplicaSetBackupApiRequest) *admin.DiskBackupReplicaSet); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupReplicaSet) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetReplicaSetBackupApiRequest) *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.GetReplicaSetBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetReplicaSetBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicaSetBackupExecute' +type CloudBackupsApi_GetReplicaSetBackupExecute_Call struct { + *mock.Call +} + +// GetReplicaSetBackupExecute is a helper method to define mock.On call +// - r admin.GetReplicaSetBackupApiRequest +func (_e *CloudBackupsApi_Expecter) GetReplicaSetBackupExecute(r interface{}) *CloudBackupsApi_GetReplicaSetBackupExecute_Call { + return &CloudBackupsApi_GetReplicaSetBackupExecute_Call{Call: _e.mock.On("GetReplicaSetBackupExecute", r)} +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupExecute_Call) Run(run func(r admin.GetReplicaSetBackupApiRequest)) *CloudBackupsApi_GetReplicaSetBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetReplicaSetBackupApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupExecute_Call) Return(_a0 *admin.DiskBackupReplicaSet, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetReplicaSetBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupExecute_Call) RunAndReturn(run func(admin.GetReplicaSetBackupApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_GetReplicaSetBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetReplicaSetBackupWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetReplicaSetBackupWithParams(ctx context.Context, args *admin.GetReplicaSetBackupApiParams) admin.GetReplicaSetBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetReplicaSetBackupWithParams") + } + + var r0 admin.GetReplicaSetBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetReplicaSetBackupApiParams) admin.GetReplicaSetBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetReplicaSetBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetReplicaSetBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicaSetBackupWithParams' +type CloudBackupsApi_GetReplicaSetBackupWithParams_Call struct { + *mock.Call +} + +// GetReplicaSetBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetReplicaSetBackupApiParams +func (_e *CloudBackupsApi_Expecter) GetReplicaSetBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call { + return &CloudBackupsApi_GetReplicaSetBackupWithParams_Call{Call: _e.mock.On("GetReplicaSetBackupWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.GetReplicaSetBackupApiParams)) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetReplicaSetBackupApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupWithParams_Call) Return(_a0 admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetReplicaSetBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetReplicaSetBackupApiParams) admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *CloudBackupsApi) GetServerlessBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetServerlessBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackup") + } + + var r0 admin.GetServerlessBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetServerlessBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.GetServerlessBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetServerlessBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackup' +type CloudBackupsApi_GetServerlessBackup_Call struct { + *mock.Call +} + +// GetServerlessBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *CloudBackupsApi_Expecter) GetServerlessBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *CloudBackupsApi_GetServerlessBackup_Call { + return &CloudBackupsApi_GetServerlessBackup_Call{Call: _e.mock.On("GetServerlessBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *CloudBackupsApi_GetServerlessBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetServerlessBackup_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 *CloudBackupsApi_GetServerlessBackup_Call) Return(_a0 admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackup_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackupExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetServerlessBackupExecute(r admin.GetServerlessBackupApiRequest) (*admin.ServerlessBackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackupExecute") + } + + var r0 *admin.ServerlessBackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetServerlessBackupApiRequest) (*admin.ServerlessBackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetServerlessBackupApiRequest) *admin.ServerlessBackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessBackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetServerlessBackupApiRequest) *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.GetServerlessBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetServerlessBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackupExecute' +type CloudBackupsApi_GetServerlessBackupExecute_Call struct { + *mock.Call +} + +// GetServerlessBackupExecute is a helper method to define mock.On call +// - r admin.GetServerlessBackupApiRequest +func (_e *CloudBackupsApi_Expecter) GetServerlessBackupExecute(r interface{}) *CloudBackupsApi_GetServerlessBackupExecute_Call { + return &CloudBackupsApi_GetServerlessBackupExecute_Call{Call: _e.mock.On("GetServerlessBackupExecute", r)} +} + +func (_c *CloudBackupsApi_GetServerlessBackupExecute_Call) Run(run func(r admin.GetServerlessBackupApiRequest)) *CloudBackupsApi_GetServerlessBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetServerlessBackupApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupExecute_Call) Return(_a0 *admin.ServerlessBackupSnapshot, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetServerlessBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupExecute_Call) RunAndReturn(run func(admin.GetServerlessBackupApiRequest) (*admin.ServerlessBackupSnapshot, *http.Response, error)) *CloudBackupsApi_GetServerlessBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId +func (_m *CloudBackupsApi) GetServerlessBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.GetServerlessBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, restoreJobId) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackupRestoreJob") + } + + var r0 admin.GetServerlessBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetServerlessBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, restoreJobId) + } else { + r0 = ret.Get(0).(admin.GetServerlessBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetServerlessBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackupRestoreJob' +type CloudBackupsApi_GetServerlessBackupRestoreJob_Call struct { + *mock.Call +} + +// GetServerlessBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - restoreJobId string +func (_e *CloudBackupsApi_Expecter) GetServerlessBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, restoreJobId interface{}) *CloudBackupsApi_GetServerlessBackupRestoreJob_Call { + return &CloudBackupsApi_GetServerlessBackupRestoreJob_Call{Call: _e.mock.On("GetServerlessBackupRestoreJob", ctx, groupId, clusterName, restoreJobId)} +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_GetServerlessBackupRestoreJob_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 *CloudBackupsApi_GetServerlessBackupRestoreJob_Call) Return(_a0 admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetServerlessBackupRestoreJobExecute(r admin.GetServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackupRestoreJobExecute") + } + + var r0 *admin.ServerlessBackupRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetServerlessBackupRestoreJobApiRequest) *admin.ServerlessBackupRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessBackupRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetServerlessBackupRestoreJobApiRequest) *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.GetServerlessBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackupRestoreJobExecute' +type CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// GetServerlessBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.GetServerlessBackupRestoreJobApiRequest +func (_e *CloudBackupsApi_Expecter) GetServerlessBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call { + return &CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call{Call: _e.mock.On("GetServerlessBackupRestoreJobExecute", r)} +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call) Run(run func(r admin.GetServerlessBackupRestoreJobApiRequest)) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetServerlessBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call) Return(_a0 *admin.ServerlessBackupRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetServerlessBackupRestoreJobWithParams(ctx context.Context, args *admin.GetServerlessBackupRestoreJobApiParams) admin.GetServerlessBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackupRestoreJobWithParams") + } + + var r0 admin.GetServerlessBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessBackupRestoreJobApiParams) admin.GetServerlessBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetServerlessBackupRestoreJobApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackupRestoreJobWithParams' +type CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// GetServerlessBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetServerlessBackupRestoreJobApiParams +func (_e *CloudBackupsApi_Expecter) GetServerlessBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call { + return &CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetServerlessBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessBackupRestoreJobApiParams)) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetServerlessBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call) Return(_a0 admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessBackupRestoreJobApiParams) admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessBackupWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetServerlessBackupWithParams(ctx context.Context, args *admin.GetServerlessBackupApiParams) admin.GetServerlessBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessBackupWithParams") + } + + var r0 admin.GetServerlessBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessBackupApiParams) admin.GetServerlessBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetServerlessBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetServerlessBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessBackupWithParams' +type CloudBackupsApi_GetServerlessBackupWithParams_Call struct { + *mock.Call +} + +// GetServerlessBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetServerlessBackupApiParams +func (_e *CloudBackupsApi_Expecter) GetServerlessBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetServerlessBackupWithParams_Call { + return &CloudBackupsApi_GetServerlessBackupWithParams_Call{Call: _e.mock.On("GetServerlessBackupWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetServerlessBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessBackupApiParams)) *CloudBackupsApi_GetServerlessBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetServerlessBackupApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupWithParams_Call) Return(_a0 admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetServerlessBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessBackupApiParams) admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetShardedClusterBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *CloudBackupsApi) GetShardedClusterBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetShardedClusterBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for GetShardedClusterBackup") + } + + var r0 admin.GetShardedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetShardedClusterBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.GetShardedClusterBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetShardedClusterBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardedClusterBackup' +type CloudBackupsApi_GetShardedClusterBackup_Call struct { + *mock.Call +} + +// GetShardedClusterBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *CloudBackupsApi_Expecter) GetShardedClusterBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *CloudBackupsApi_GetShardedClusterBackup_Call { + return &CloudBackupsApi_GetShardedClusterBackup_Call{Call: _e.mock.On("GetShardedClusterBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *CloudBackupsApi_GetShardedClusterBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetShardedClusterBackup_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 *CloudBackupsApi_GetShardedClusterBackup_Call) Return(_a0 admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetShardedClusterBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackup_Call { + _c.Call.Return(run) + return _c +} + +// GetShardedClusterBackupExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) GetShardedClusterBackupExecute(r admin.GetShardedClusterBackupApiRequest) (*admin.DiskBackupShardedClusterSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetShardedClusterBackupExecute") + } + + var r0 *admin.DiskBackupShardedClusterSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetShardedClusterBackupApiRequest) (*admin.DiskBackupShardedClusterSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetShardedClusterBackupApiRequest) *admin.DiskBackupShardedClusterSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupShardedClusterSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetShardedClusterBackupApiRequest) *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.GetShardedClusterBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_GetShardedClusterBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardedClusterBackupExecute' +type CloudBackupsApi_GetShardedClusterBackupExecute_Call struct { + *mock.Call +} + +// GetShardedClusterBackupExecute is a helper method to define mock.On call +// - r admin.GetShardedClusterBackupApiRequest +func (_e *CloudBackupsApi_Expecter) GetShardedClusterBackupExecute(r interface{}) *CloudBackupsApi_GetShardedClusterBackupExecute_Call { + return &CloudBackupsApi_GetShardedClusterBackupExecute_Call{Call: _e.mock.On("GetShardedClusterBackupExecute", r)} +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupExecute_Call) Run(run func(r admin.GetShardedClusterBackupApiRequest)) *CloudBackupsApi_GetShardedClusterBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetShardedClusterBackupApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupExecute_Call) Return(_a0 *admin.DiskBackupShardedClusterSnapshot, _a1 *http.Response, _a2 error) *CloudBackupsApi_GetShardedClusterBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupExecute_Call) RunAndReturn(run func(admin.GetShardedClusterBackupApiRequest) (*admin.DiskBackupShardedClusterSnapshot, *http.Response, error)) *CloudBackupsApi_GetShardedClusterBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetShardedClusterBackupWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) GetShardedClusterBackupWithParams(ctx context.Context, args *admin.GetShardedClusterBackupApiParams) admin.GetShardedClusterBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetShardedClusterBackupWithParams") + } + + var r0 admin.GetShardedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetShardedClusterBackupApiParams) admin.GetShardedClusterBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetShardedClusterBackupApiRequest) + } + + return r0 +} + +// CloudBackupsApi_GetShardedClusterBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardedClusterBackupWithParams' +type CloudBackupsApi_GetShardedClusterBackupWithParams_Call struct { + *mock.Call +} + +// GetShardedClusterBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetShardedClusterBackupApiParams +func (_e *CloudBackupsApi_Expecter) GetShardedClusterBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call { + return &CloudBackupsApi_GetShardedClusterBackupWithParams_Call{Call: _e.mock.On("GetShardedClusterBackupWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.GetShardedClusterBackupApiParams)) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetShardedClusterBackupApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupWithParams_Call) Return(_a0 admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_GetShardedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetShardedClusterBackupApiParams) admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupExportJobs provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListBackupExportJobs(ctx context.Context, groupId string, clusterName string) admin.ListBackupExportJobsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListBackupExportJobs") + } + + var r0 admin.ListBackupExportJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListBackupExportJobsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListBackupExportJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListBackupExportJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupExportJobs' +type CloudBackupsApi_ListBackupExportJobs_Call struct { + *mock.Call +} + +// ListBackupExportJobs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListBackupExportJobs(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListBackupExportJobs_Call { + return &CloudBackupsApi_ListBackupExportJobs_Call{Call: _e.mock.On("ListBackupExportJobs", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListBackupExportJobs_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListBackupExportJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobs_Call) Return(_a0 admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobs_Call) RunAndReturn(run func(context.Context, string, string) admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupExportJobsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListBackupExportJobsExecute(r admin.ListBackupExportJobsApiRequest) (*admin.PaginatedApiAtlasDiskBackupExportJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListBackupExportJobsExecute") + } + + var r0 *admin.PaginatedApiAtlasDiskBackupExportJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListBackupExportJobsApiRequest) (*admin.PaginatedApiAtlasDiskBackupExportJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListBackupExportJobsApiRequest) *admin.PaginatedApiAtlasDiskBackupExportJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiAtlasDiskBackupExportJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListBackupExportJobsApiRequest) *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.ListBackupExportJobsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListBackupExportJobsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupExportJobsExecute' +type CloudBackupsApi_ListBackupExportJobsExecute_Call struct { + *mock.Call +} + +// ListBackupExportJobsExecute is a helper method to define mock.On call +// - r admin.ListBackupExportJobsApiRequest +func (_e *CloudBackupsApi_Expecter) ListBackupExportJobsExecute(r interface{}) *CloudBackupsApi_ListBackupExportJobsExecute_Call { + return &CloudBackupsApi_ListBackupExportJobsExecute_Call{Call: _e.mock.On("ListBackupExportJobsExecute", r)} +} + +func (_c *CloudBackupsApi_ListBackupExportJobsExecute_Call) Run(run func(r admin.ListBackupExportJobsApiRequest)) *CloudBackupsApi_ListBackupExportJobsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListBackupExportJobsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobsExecute_Call) Return(_a0 *admin.PaginatedApiAtlasDiskBackupExportJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListBackupExportJobsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobsExecute_Call) RunAndReturn(run func(admin.ListBackupExportJobsApiRequest) (*admin.PaginatedApiAtlasDiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_ListBackupExportJobsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupExportJobsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListBackupExportJobsWithParams(ctx context.Context, args *admin.ListBackupExportJobsApiParams) admin.ListBackupExportJobsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListBackupExportJobsWithParams") + } + + var r0 admin.ListBackupExportJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListBackupExportJobsApiParams) admin.ListBackupExportJobsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListBackupExportJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListBackupExportJobsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupExportJobsWithParams' +type CloudBackupsApi_ListBackupExportJobsWithParams_Call struct { + *mock.Call +} + +// ListBackupExportJobsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListBackupExportJobsApiParams +func (_e *CloudBackupsApi_Expecter) ListBackupExportJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListBackupExportJobsWithParams_Call { + return &CloudBackupsApi_ListBackupExportJobsWithParams_Call{Call: _e.mock.On("ListBackupExportJobsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListBackupExportJobsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListBackupExportJobsApiParams)) *CloudBackupsApi_ListBackupExportJobsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListBackupExportJobsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobsWithParams_Call) Return(_a0 admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListBackupExportJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListBackupExportJobsApiParams) admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupRestoreJobs provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListBackupRestoreJobs(ctx context.Context, groupId string, clusterName string) admin.ListBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListBackupRestoreJobs") + } + + var r0 admin.ListBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListBackupRestoreJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListBackupRestoreJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupRestoreJobs' +type CloudBackupsApi_ListBackupRestoreJobs_Call struct { + *mock.Call +} + +// ListBackupRestoreJobs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListBackupRestoreJobs(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListBackupRestoreJobs_Call { + return &CloudBackupsApi_ListBackupRestoreJobs_Call{Call: _e.mock.On("ListBackupRestoreJobs", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobs_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListBackupRestoreJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobs_Call) Return(_a0 admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobs_Call) RunAndReturn(run func(context.Context, string, string) admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupRestoreJobsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListBackupRestoreJobsExecute(r admin.ListBackupRestoreJobsApiRequest) (*admin.PaginatedCloudBackupRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListBackupRestoreJobsExecute") + } + + var r0 *admin.PaginatedCloudBackupRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListBackupRestoreJobsApiRequest) (*admin.PaginatedCloudBackupRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListBackupRestoreJobsApiRequest) *admin.PaginatedCloudBackupRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedCloudBackupRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListBackupRestoreJobsApiRequest) *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.ListBackupRestoreJobsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListBackupRestoreJobsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupRestoreJobsExecute' +type CloudBackupsApi_ListBackupRestoreJobsExecute_Call struct { + *mock.Call +} + +// ListBackupRestoreJobsExecute is a helper method to define mock.On call +// - r admin.ListBackupRestoreJobsApiRequest +func (_e *CloudBackupsApi_Expecter) ListBackupRestoreJobsExecute(r interface{}) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call { + return &CloudBackupsApi_ListBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListBackupRestoreJobsExecute", r)} +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsExecute_Call) Run(run func(r admin.ListBackupRestoreJobsApiRequest)) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListBackupRestoreJobsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsExecute_Call) Return(_a0 *admin.PaginatedCloudBackupRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListBackupRestoreJobsApiRequest) (*admin.PaginatedCloudBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListBackupRestoreJobsApiParams) admin.ListBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListBackupRestoreJobsWithParams") + } + + var r0 admin.ListBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListBackupRestoreJobsApiParams) admin.ListBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListBackupRestoreJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListBackupRestoreJobsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackupRestoreJobsWithParams' +type CloudBackupsApi_ListBackupRestoreJobsWithParams_Call struct { + *mock.Call +} + +// ListBackupRestoreJobsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListBackupRestoreJobsApiParams +func (_e *CloudBackupsApi_Expecter) ListBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call { + return &CloudBackupsApi_ListBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListBackupRestoreJobsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListBackupRestoreJobsApiParams)) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListBackupRestoreJobsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListBackupRestoreJobsApiParams) admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListExportBuckets provides a mock function with given fields: ctx, groupId +func (_m *CloudBackupsApi) ListExportBuckets(ctx context.Context, groupId string) admin.ListExportBucketsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListExportBuckets") + } + + var r0 admin.ListExportBucketsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListExportBucketsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListExportBucketsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListExportBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExportBuckets' +type CloudBackupsApi_ListExportBuckets_Call struct { + *mock.Call +} + +// ListExportBuckets is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *CloudBackupsApi_Expecter) ListExportBuckets(ctx interface{}, groupId interface{}) *CloudBackupsApi_ListExportBuckets_Call { + return &CloudBackupsApi_ListExportBuckets_Call{Call: _e.mock.On("ListExportBuckets", ctx, groupId)} +} + +func (_c *CloudBackupsApi_ListExportBuckets_Call) Run(run func(ctx context.Context, groupId string)) *CloudBackupsApi_ListExportBuckets_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListExportBuckets_Call) Return(_a0 admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBuckets_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListExportBuckets_Call) RunAndReturn(run func(context.Context, string) admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBuckets_Call { + _c.Call.Return(run) + return _c +} + +// ListExportBucketsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListExportBucketsExecute(r admin.ListExportBucketsApiRequest) (*admin.PaginatedBackupSnapshotExportBucket, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListExportBucketsExecute") + } + + var r0 *admin.PaginatedBackupSnapshotExportBucket + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListExportBucketsApiRequest) (*admin.PaginatedBackupSnapshotExportBucket, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListExportBucketsApiRequest) *admin.PaginatedBackupSnapshotExportBucket); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedBackupSnapshotExportBucket) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListExportBucketsApiRequest) *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.ListExportBucketsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListExportBucketsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExportBucketsExecute' +type CloudBackupsApi_ListExportBucketsExecute_Call struct { + *mock.Call +} + +// ListExportBucketsExecute is a helper method to define mock.On call +// - r admin.ListExportBucketsApiRequest +func (_e *CloudBackupsApi_Expecter) ListExportBucketsExecute(r interface{}) *CloudBackupsApi_ListExportBucketsExecute_Call { + return &CloudBackupsApi_ListExportBucketsExecute_Call{Call: _e.mock.On("ListExportBucketsExecute", r)} +} + +func (_c *CloudBackupsApi_ListExportBucketsExecute_Call) Run(run func(r admin.ListExportBucketsApiRequest)) *CloudBackupsApi_ListExportBucketsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListExportBucketsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListExportBucketsExecute_Call) Return(_a0 *admin.PaginatedBackupSnapshotExportBucket, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListExportBucketsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListExportBucketsExecute_Call) RunAndReturn(run func(admin.ListExportBucketsApiRequest) (*admin.PaginatedBackupSnapshotExportBucket, *http.Response, error)) *CloudBackupsApi_ListExportBucketsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListExportBucketsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListExportBucketsWithParams(ctx context.Context, args *admin.ListExportBucketsApiParams) admin.ListExportBucketsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListExportBucketsWithParams") + } + + var r0 admin.ListExportBucketsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListExportBucketsApiParams) admin.ListExportBucketsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListExportBucketsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListExportBucketsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExportBucketsWithParams' +type CloudBackupsApi_ListExportBucketsWithParams_Call struct { + *mock.Call +} + +// ListExportBucketsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListExportBucketsApiParams +func (_e *CloudBackupsApi_Expecter) ListExportBucketsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListExportBucketsWithParams_Call { + return &CloudBackupsApi_ListExportBucketsWithParams_Call{Call: _e.mock.On("ListExportBucketsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListExportBucketsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListExportBucketsApiParams)) *CloudBackupsApi_ListExportBucketsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListExportBucketsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListExportBucketsWithParams_Call) Return(_a0 admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBucketsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListExportBucketsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListExportBucketsApiParams) admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBucketsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListReplicaSetBackups provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListReplicaSetBackups(ctx context.Context, groupId string, clusterName string) admin.ListReplicaSetBackupsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListReplicaSetBackups") + } + + var r0 admin.ListReplicaSetBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListReplicaSetBackupsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListReplicaSetBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListReplicaSetBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReplicaSetBackups' +type CloudBackupsApi_ListReplicaSetBackups_Call struct { + *mock.Call +} + +// ListReplicaSetBackups is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListReplicaSetBackups(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListReplicaSetBackups_Call { + return &CloudBackupsApi_ListReplicaSetBackups_Call{Call: _e.mock.On("ListReplicaSetBackups", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListReplicaSetBackups_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListReplicaSetBackups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackups_Call) Return(_a0 admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackups_Call) RunAndReturn(run func(context.Context, string, string) admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackups_Call { + _c.Call.Return(run) + return _c +} + +// ListReplicaSetBackupsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListReplicaSetBackupsExecute(r admin.ListReplicaSetBackupsApiRequest) (*admin.PaginatedCloudBackupReplicaSet, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListReplicaSetBackupsExecute") + } + + var r0 *admin.PaginatedCloudBackupReplicaSet + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListReplicaSetBackupsApiRequest) (*admin.PaginatedCloudBackupReplicaSet, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListReplicaSetBackupsApiRequest) *admin.PaginatedCloudBackupReplicaSet); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedCloudBackupReplicaSet) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListReplicaSetBackupsApiRequest) *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.ListReplicaSetBackupsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListReplicaSetBackupsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReplicaSetBackupsExecute' +type CloudBackupsApi_ListReplicaSetBackupsExecute_Call struct { + *mock.Call +} + +// ListReplicaSetBackupsExecute is a helper method to define mock.On call +// - r admin.ListReplicaSetBackupsApiRequest +func (_e *CloudBackupsApi_Expecter) ListReplicaSetBackupsExecute(r interface{}) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call { + return &CloudBackupsApi_ListReplicaSetBackupsExecute_Call{Call: _e.mock.On("ListReplicaSetBackupsExecute", r)} +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsExecute_Call) Run(run func(r admin.ListReplicaSetBackupsApiRequest)) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListReplicaSetBackupsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsExecute_Call) Return(_a0 *admin.PaginatedCloudBackupReplicaSet, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsExecute_Call) RunAndReturn(run func(admin.ListReplicaSetBackupsApiRequest) (*admin.PaginatedCloudBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListReplicaSetBackupsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListReplicaSetBackupsWithParams(ctx context.Context, args *admin.ListReplicaSetBackupsApiParams) admin.ListReplicaSetBackupsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListReplicaSetBackupsWithParams") + } + + var r0 admin.ListReplicaSetBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListReplicaSetBackupsApiParams) admin.ListReplicaSetBackupsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListReplicaSetBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListReplicaSetBackupsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReplicaSetBackupsWithParams' +type CloudBackupsApi_ListReplicaSetBackupsWithParams_Call struct { + *mock.Call +} + +// ListReplicaSetBackupsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListReplicaSetBackupsApiParams +func (_e *CloudBackupsApi_Expecter) ListReplicaSetBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call { + return &CloudBackupsApi_ListReplicaSetBackupsWithParams_Call{Call: _e.mock.On("ListReplicaSetBackupsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListReplicaSetBackupsApiParams)) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListReplicaSetBackupsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call) Return(_a0 admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListReplicaSetBackupsApiParams) admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackupRestoreJobs provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListServerlessBackupRestoreJobs(ctx context.Context, groupId string, clusterName string) admin.ListServerlessBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackupRestoreJobs") + } + + var r0 admin.ListServerlessBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListServerlessBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListServerlessBackupRestoreJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListServerlessBackupRestoreJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackupRestoreJobs' +type CloudBackupsApi_ListServerlessBackupRestoreJobs_Call struct { + *mock.Call +} + +// ListServerlessBackupRestoreJobs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListServerlessBackupRestoreJobs(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call { + return &CloudBackupsApi_ListServerlessBackupRestoreJobs_Call{Call: _e.mock.On("ListServerlessBackupRestoreJobs", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call) Return(_a0 admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call) RunAndReturn(run func(context.Context, string, string) admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackupRestoreJobsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListServerlessBackupRestoreJobsExecute(r admin.ListServerlessBackupRestoreJobsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackupRestoreJobsExecute") + } + + var r0 *admin.PaginatedApiAtlasServerlessBackupRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListServerlessBackupRestoreJobsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListServerlessBackupRestoreJobsApiRequest) *admin.PaginatedApiAtlasServerlessBackupRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiAtlasServerlessBackupRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListServerlessBackupRestoreJobsApiRequest) *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.ListServerlessBackupRestoreJobsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackupRestoreJobsExecute' +type CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call struct { + *mock.Call +} + +// ListServerlessBackupRestoreJobsExecute is a helper method to define mock.On call +// - r admin.ListServerlessBackupRestoreJobsApiRequest +func (_e *CloudBackupsApi_Expecter) ListServerlessBackupRestoreJobsExecute(r interface{}) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call { + return &CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListServerlessBackupRestoreJobsExecute", r)} +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call) Run(run func(r admin.ListServerlessBackupRestoreJobsApiRequest)) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListServerlessBackupRestoreJobsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call) Return(_a0 *admin.PaginatedApiAtlasServerlessBackupRestoreJob, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListServerlessBackupRestoreJobsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListServerlessBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListServerlessBackupRestoreJobsApiParams) admin.ListServerlessBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackupRestoreJobsWithParams") + } + + var r0 admin.ListServerlessBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListServerlessBackupRestoreJobsApiParams) admin.ListServerlessBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListServerlessBackupRestoreJobsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackupRestoreJobsWithParams' +type CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call struct { + *mock.Call +} + +// ListServerlessBackupRestoreJobsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListServerlessBackupRestoreJobsApiParams +func (_e *CloudBackupsApi_Expecter) ListServerlessBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call { + return &CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListServerlessBackupRestoreJobsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListServerlessBackupRestoreJobsApiParams)) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListServerlessBackupRestoreJobsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessBackupRestoreJobsApiParams) admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackups provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListServerlessBackups(ctx context.Context, groupId string, clusterName string) admin.ListServerlessBackupsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackups") + } + + var r0 admin.ListServerlessBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListServerlessBackupsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListServerlessBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListServerlessBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackups' +type CloudBackupsApi_ListServerlessBackups_Call struct { + *mock.Call +} + +// ListServerlessBackups is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListServerlessBackups(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListServerlessBackups_Call { + return &CloudBackupsApi_ListServerlessBackups_Call{Call: _e.mock.On("ListServerlessBackups", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListServerlessBackups_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListServerlessBackups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackups_Call) Return(_a0 admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackups_Call) RunAndReturn(run func(context.Context, string, string) admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackups_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackupsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListServerlessBackupsExecute(r admin.ListServerlessBackupsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackupsExecute") + } + + var r0 *admin.PaginatedApiAtlasServerlessBackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListServerlessBackupsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListServerlessBackupsApiRequest) *admin.PaginatedApiAtlasServerlessBackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiAtlasServerlessBackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListServerlessBackupsApiRequest) *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.ListServerlessBackupsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListServerlessBackupsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackupsExecute' +type CloudBackupsApi_ListServerlessBackupsExecute_Call struct { + *mock.Call +} + +// ListServerlessBackupsExecute is a helper method to define mock.On call +// - r admin.ListServerlessBackupsApiRequest +func (_e *CloudBackupsApi_Expecter) ListServerlessBackupsExecute(r interface{}) *CloudBackupsApi_ListServerlessBackupsExecute_Call { + return &CloudBackupsApi_ListServerlessBackupsExecute_Call{Call: _e.mock.On("ListServerlessBackupsExecute", r)} +} + +func (_c *CloudBackupsApi_ListServerlessBackupsExecute_Call) Run(run func(r admin.ListServerlessBackupsApiRequest)) *CloudBackupsApi_ListServerlessBackupsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListServerlessBackupsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupsExecute_Call) Return(_a0 *admin.PaginatedApiAtlasServerlessBackupSnapshot, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListServerlessBackupsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupsExecute_Call) RunAndReturn(run func(admin.ListServerlessBackupsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupSnapshot, *http.Response, error)) *CloudBackupsApi_ListServerlessBackupsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessBackupsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListServerlessBackupsWithParams(ctx context.Context, args *admin.ListServerlessBackupsApiParams) admin.ListServerlessBackupsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessBackupsWithParams") + } + + var r0 admin.ListServerlessBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListServerlessBackupsApiParams) admin.ListServerlessBackupsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListServerlessBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListServerlessBackupsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessBackupsWithParams' +type CloudBackupsApi_ListServerlessBackupsWithParams_Call struct { + *mock.Call +} + +// ListServerlessBackupsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListServerlessBackupsApiParams +func (_e *CloudBackupsApi_Expecter) ListServerlessBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListServerlessBackupsWithParams_Call { + return &CloudBackupsApi_ListServerlessBackupsWithParams_Call{Call: _e.mock.On("ListServerlessBackupsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListServerlessBackupsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListServerlessBackupsApiParams)) *CloudBackupsApi_ListServerlessBackupsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListServerlessBackupsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupsWithParams_Call) Return(_a0 admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackupsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListServerlessBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessBackupsApiParams) admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackupsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListShardedClusterBackups provides a mock function with given fields: ctx, groupId, clusterName +func (_m *CloudBackupsApi) ListShardedClusterBackups(ctx context.Context, groupId string, clusterName string) admin.ListShardedClusterBackupsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListShardedClusterBackups") + } + + var r0 admin.ListShardedClusterBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListShardedClusterBackupsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListShardedClusterBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListShardedClusterBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShardedClusterBackups' +type CloudBackupsApi_ListShardedClusterBackups_Call struct { + *mock.Call +} + +// ListShardedClusterBackups is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *CloudBackupsApi_Expecter) ListShardedClusterBackups(ctx interface{}, groupId interface{}, clusterName interface{}) *CloudBackupsApi_ListShardedClusterBackups_Call { + return &CloudBackupsApi_ListShardedClusterBackups_Call{Call: _e.mock.On("ListShardedClusterBackups", ctx, groupId, clusterName)} +} + +func (_c *CloudBackupsApi_ListShardedClusterBackups_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *CloudBackupsApi_ListShardedClusterBackups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackups_Call) Return(_a0 admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackups_Call) RunAndReturn(run func(context.Context, string, string) admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackups_Call { + _c.Call.Return(run) + return _c +} + +// ListShardedClusterBackupsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) ListShardedClusterBackupsExecute(r admin.ListShardedClusterBackupsApiRequest) (*admin.PaginatedCloudBackupShardedClusterSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListShardedClusterBackupsExecute") + } + + var r0 *admin.PaginatedCloudBackupShardedClusterSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListShardedClusterBackupsApiRequest) (*admin.PaginatedCloudBackupShardedClusterSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListShardedClusterBackupsApiRequest) *admin.PaginatedCloudBackupShardedClusterSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedCloudBackupShardedClusterSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListShardedClusterBackupsApiRequest) *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.ListShardedClusterBackupsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_ListShardedClusterBackupsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShardedClusterBackupsExecute' +type CloudBackupsApi_ListShardedClusterBackupsExecute_Call struct { + *mock.Call +} + +// ListShardedClusterBackupsExecute is a helper method to define mock.On call +// - r admin.ListShardedClusterBackupsApiRequest +func (_e *CloudBackupsApi_Expecter) ListShardedClusterBackupsExecute(r interface{}) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call { + return &CloudBackupsApi_ListShardedClusterBackupsExecute_Call{Call: _e.mock.On("ListShardedClusterBackupsExecute", r)} +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsExecute_Call) Run(run func(r admin.ListShardedClusterBackupsApiRequest)) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListShardedClusterBackupsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsExecute_Call) Return(_a0 *admin.PaginatedCloudBackupShardedClusterSnapshot, _a1 *http.Response, _a2 error) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsExecute_Call) RunAndReturn(run func(admin.ListShardedClusterBackupsApiRequest) (*admin.PaginatedCloudBackupShardedClusterSnapshot, *http.Response, error)) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListShardedClusterBackupsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) ListShardedClusterBackupsWithParams(ctx context.Context, args *admin.ListShardedClusterBackupsApiParams) admin.ListShardedClusterBackupsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListShardedClusterBackupsWithParams") + } + + var r0 admin.ListShardedClusterBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListShardedClusterBackupsApiParams) admin.ListShardedClusterBackupsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListShardedClusterBackupsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_ListShardedClusterBackupsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShardedClusterBackupsWithParams' +type CloudBackupsApi_ListShardedClusterBackupsWithParams_Call struct { + *mock.Call +} + +// ListShardedClusterBackupsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListShardedClusterBackupsApiParams +func (_e *CloudBackupsApi_Expecter) ListShardedClusterBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call { + return &CloudBackupsApi_ListShardedClusterBackupsWithParams_Call{Call: _e.mock.On("ListShardedClusterBackupsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListShardedClusterBackupsApiParams)) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListShardedClusterBackupsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call) Return(_a0 admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListShardedClusterBackupsApiParams) admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// TakeSnapshot provides a mock function with given fields: ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest +func (_m *CloudBackupsApi) TakeSnapshot(ctx context.Context, groupId string, clusterName string, diskBackupOnDemandSnapshotRequest *admin.DiskBackupOnDemandSnapshotRequest) admin.TakeSnapshotApiRequest { + ret := _m.Called(ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest) + + if len(ret) == 0 { + panic("no return value specified for TakeSnapshot") + } + + var r0 admin.TakeSnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DiskBackupOnDemandSnapshotRequest) admin.TakeSnapshotApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest) + } else { + r0 = ret.Get(0).(admin.TakeSnapshotApiRequest) + } + + return r0 +} + +// CloudBackupsApi_TakeSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TakeSnapshot' +type CloudBackupsApi_TakeSnapshot_Call struct { + *mock.Call +} + +// TakeSnapshot is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - diskBackupOnDemandSnapshotRequest *admin.DiskBackupOnDemandSnapshotRequest +func (_e *CloudBackupsApi_Expecter) TakeSnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupOnDemandSnapshotRequest interface{}) *CloudBackupsApi_TakeSnapshot_Call { + return &CloudBackupsApi_TakeSnapshot_Call{Call: _e.mock.On("TakeSnapshot", ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest)} +} + +func (_c *CloudBackupsApi_TakeSnapshot_Call) Run(run func(ctx context.Context, groupId string, clusterName string, diskBackupOnDemandSnapshotRequest *admin.DiskBackupOnDemandSnapshotRequest)) *CloudBackupsApi_TakeSnapshot_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DiskBackupOnDemandSnapshotRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshot_Call) Return(_a0 admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshot_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupOnDemandSnapshotRequest) admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshot_Call { + _c.Call.Return(run) + return _c +} + +// TakeSnapshotExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) TakeSnapshotExecute(r admin.TakeSnapshotApiRequest) (*admin.DiskBackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for TakeSnapshotExecute") + } + + var r0 *admin.DiskBackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.TakeSnapshotApiRequest) (*admin.DiskBackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.TakeSnapshotApiRequest) *admin.DiskBackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.TakeSnapshotApiRequest) *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.TakeSnapshotApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_TakeSnapshotExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TakeSnapshotExecute' +type CloudBackupsApi_TakeSnapshotExecute_Call struct { + *mock.Call +} + +// TakeSnapshotExecute is a helper method to define mock.On call +// - r admin.TakeSnapshotApiRequest +func (_e *CloudBackupsApi_Expecter) TakeSnapshotExecute(r interface{}) *CloudBackupsApi_TakeSnapshotExecute_Call { + return &CloudBackupsApi_TakeSnapshotExecute_Call{Call: _e.mock.On("TakeSnapshotExecute", r)} +} + +func (_c *CloudBackupsApi_TakeSnapshotExecute_Call) Run(run func(r admin.TakeSnapshotApiRequest)) *CloudBackupsApi_TakeSnapshotExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.TakeSnapshotApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshotExecute_Call) Return(_a0 *admin.DiskBackupSnapshot, _a1 *http.Response, _a2 error) *CloudBackupsApi_TakeSnapshotExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshotExecute_Call) RunAndReturn(run func(admin.TakeSnapshotApiRequest) (*admin.DiskBackupSnapshot, *http.Response, error)) *CloudBackupsApi_TakeSnapshotExecute_Call { + _c.Call.Return(run) + return _c +} + +// TakeSnapshotWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) TakeSnapshotWithParams(ctx context.Context, args *admin.TakeSnapshotApiParams) admin.TakeSnapshotApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for TakeSnapshotWithParams") + } + + var r0 admin.TakeSnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.TakeSnapshotApiParams) admin.TakeSnapshotApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.TakeSnapshotApiRequest) + } + + return r0 +} + +// CloudBackupsApi_TakeSnapshotWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TakeSnapshotWithParams' +type CloudBackupsApi_TakeSnapshotWithParams_Call struct { + *mock.Call +} + +// TakeSnapshotWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.TakeSnapshotApiParams +func (_e *CloudBackupsApi_Expecter) TakeSnapshotWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_TakeSnapshotWithParams_Call { + return &CloudBackupsApi_TakeSnapshotWithParams_Call{Call: _e.mock.On("TakeSnapshotWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_TakeSnapshotWithParams_Call) Run(run func(ctx context.Context, args *admin.TakeSnapshotApiParams)) *CloudBackupsApi_TakeSnapshotWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.TakeSnapshotApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshotWithParams_Call) Return(_a0 admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshotWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_TakeSnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.TakeSnapshotApiParams) admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshotWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateBackupSchedule provides a mock function with given fields: ctx, groupId, clusterName, diskBackupSnapshotSchedule +func (_m *CloudBackupsApi) UpdateBackupSchedule(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotSchedule *admin.DiskBackupSnapshotSchedule) admin.UpdateBackupScheduleApiRequest { + ret := _m.Called(ctx, groupId, clusterName, diskBackupSnapshotSchedule) + + if len(ret) == 0 { + panic("no return value specified for UpdateBackupSchedule") + } + + var r0 admin.UpdateBackupScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DiskBackupSnapshotSchedule) admin.UpdateBackupScheduleApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, diskBackupSnapshotSchedule) + } else { + r0 = ret.Get(0).(admin.UpdateBackupScheduleApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateBackupSchedule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBackupSchedule' +type CloudBackupsApi_UpdateBackupSchedule_Call struct { + *mock.Call +} + +// UpdateBackupSchedule is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - diskBackupSnapshotSchedule *admin.DiskBackupSnapshotSchedule +func (_e *CloudBackupsApi_Expecter) UpdateBackupSchedule(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupSnapshotSchedule interface{}) *CloudBackupsApi_UpdateBackupSchedule_Call { + return &CloudBackupsApi_UpdateBackupSchedule_Call{Call: _e.mock.On("UpdateBackupSchedule", ctx, groupId, clusterName, diskBackupSnapshotSchedule)} +} + +func (_c *CloudBackupsApi_UpdateBackupSchedule_Call) Run(run func(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotSchedule *admin.DiskBackupSnapshotSchedule)) *CloudBackupsApi_UpdateBackupSchedule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DiskBackupSnapshotSchedule)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupSchedule_Call) Return(_a0 admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupSchedule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupSchedule_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupSnapshotSchedule) admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupSchedule_Call { + _c.Call.Return(run) + return _c +} + +// UpdateBackupScheduleExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) UpdateBackupScheduleExecute(r admin.UpdateBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateBackupScheduleExecute") + } + + var r0 *admin.DiskBackupSnapshotSchedule + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateBackupScheduleApiRequest) *admin.DiskBackupSnapshotSchedule); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupSnapshotSchedule) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateBackupScheduleApiRequest) *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.UpdateBackupScheduleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_UpdateBackupScheduleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBackupScheduleExecute' +type CloudBackupsApi_UpdateBackupScheduleExecute_Call struct { + *mock.Call +} + +// UpdateBackupScheduleExecute is a helper method to define mock.On call +// - r admin.UpdateBackupScheduleApiRequest +func (_e *CloudBackupsApi_Expecter) UpdateBackupScheduleExecute(r interface{}) *CloudBackupsApi_UpdateBackupScheduleExecute_Call { + return &CloudBackupsApi_UpdateBackupScheduleExecute_Call{Call: _e.mock.On("UpdateBackupScheduleExecute", r)} +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleExecute_Call) Run(run func(r admin.UpdateBackupScheduleApiRequest)) *CloudBackupsApi_UpdateBackupScheduleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateBackupScheduleApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleExecute_Call) Return(_a0 *admin.DiskBackupSnapshotSchedule, _a1 *http.Response, _a2 error) *CloudBackupsApi_UpdateBackupScheduleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleExecute_Call) RunAndReturn(run func(admin.UpdateBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_UpdateBackupScheduleExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateBackupScheduleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) UpdateBackupScheduleWithParams(ctx context.Context, args *admin.UpdateBackupScheduleApiParams) admin.UpdateBackupScheduleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateBackupScheduleWithParams") + } + + var r0 admin.UpdateBackupScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateBackupScheduleApiParams) admin.UpdateBackupScheduleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateBackupScheduleApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateBackupScheduleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBackupScheduleWithParams' +type CloudBackupsApi_UpdateBackupScheduleWithParams_Call struct { + *mock.Call +} + +// UpdateBackupScheduleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateBackupScheduleApiParams +func (_e *CloudBackupsApi_Expecter) UpdateBackupScheduleWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call { + return &CloudBackupsApi_UpdateBackupScheduleWithParams_Call{Call: _e.mock.On("UpdateBackupScheduleWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateBackupScheduleApiParams)) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateBackupScheduleApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleWithParams_Call) Return(_a0 admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateBackupScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateBackupScheduleApiParams) admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataProtectionSettings provides a mock function with given fields: ctx, groupId, dataProtectionSettings20231001 +func (_m *CloudBackupsApi) UpdateDataProtectionSettings(ctx context.Context, groupId string, dataProtectionSettings20231001 *admin.DataProtectionSettings20231001) admin.UpdateDataProtectionSettingsApiRequest { + ret := _m.Called(ctx, groupId, dataProtectionSettings20231001) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataProtectionSettings") + } + + var r0 admin.UpdateDataProtectionSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.DataProtectionSettings20231001) admin.UpdateDataProtectionSettingsApiRequest); ok { + r0 = rf(ctx, groupId, dataProtectionSettings20231001) + } else { + r0 = ret.Get(0).(admin.UpdateDataProtectionSettingsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateDataProtectionSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataProtectionSettings' +type CloudBackupsApi_UpdateDataProtectionSettings_Call struct { + *mock.Call +} + +// UpdateDataProtectionSettings is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - dataProtectionSettings20231001 *admin.DataProtectionSettings20231001 +func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettings(ctx interface{}, groupId interface{}, dataProtectionSettings20231001 interface{}) *CloudBackupsApi_UpdateDataProtectionSettings_Call { + return &CloudBackupsApi_UpdateDataProtectionSettings_Call{Call: _e.mock.On("UpdateDataProtectionSettings", ctx, groupId, dataProtectionSettings20231001)} +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettings_Call) Run(run func(ctx context.Context, groupId string, dataProtectionSettings20231001 *admin.DataProtectionSettings20231001)) *CloudBackupsApi_UpdateDataProtectionSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.DataProtectionSettings20231001)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettings_Call) Return(_a0 admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettings_Call) RunAndReturn(run func(context.Context, string, *admin.DataProtectionSettings20231001) admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettings_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataProtectionSettingsExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) UpdateDataProtectionSettingsExecute(r admin.UpdateDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataProtectionSettingsExecute") + } + + var r0 *admin.DataProtectionSettings20231001 + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateDataProtectionSettingsApiRequest) *admin.DataProtectionSettings20231001); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataProtectionSettings20231001) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateDataProtectionSettingsApiRequest) *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.UpdateDataProtectionSettingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataProtectionSettingsExecute' +type CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call struct { + *mock.Call +} + +// UpdateDataProtectionSettingsExecute is a helper method to define mock.On call +// - r admin.UpdateDataProtectionSettingsApiRequest +func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettingsExecute(r interface{}) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call { + return &CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call{Call: _e.mock.On("UpdateDataProtectionSettingsExecute", r)} +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call) Run(run func(r admin.UpdateDataProtectionSettingsApiRequest)) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateDataProtectionSettingsApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call) Return(_a0 *admin.DataProtectionSettings20231001, _a1 *http.Response, _a2 error) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call) RunAndReturn(run func(admin.UpdateDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataProtectionSettingsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) UpdateDataProtectionSettingsWithParams(ctx context.Context, args *admin.UpdateDataProtectionSettingsApiParams) admin.UpdateDataProtectionSettingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataProtectionSettingsWithParams") + } + + var r0 admin.UpdateDataProtectionSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateDataProtectionSettingsApiParams) admin.UpdateDataProtectionSettingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateDataProtectionSettingsApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataProtectionSettingsWithParams' +type CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call struct { + *mock.Call +} + +// UpdateDataProtectionSettingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateDataProtectionSettingsApiParams +func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettingsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call { + return &CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call{Call: _e.mock.On("UpdateDataProtectionSettingsWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateDataProtectionSettingsApiParams)) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateDataProtectionSettingsApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call) Return(_a0 admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateDataProtectionSettingsApiParams) admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSnapshotRetention provides a mock function with given fields: ctx, groupId, clusterName, snapshotId, backupSnapshotRetention +func (_m *CloudBackupsApi) UpdateSnapshotRetention(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshotRetention *admin.BackupSnapshotRetention) admin.UpdateSnapshotRetentionApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId, backupSnapshotRetention) + + if len(ret) == 0 { + panic("no return value specified for UpdateSnapshotRetention") + } + + var r0 admin.UpdateSnapshotRetentionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.BackupSnapshotRetention) admin.UpdateSnapshotRetentionApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId, backupSnapshotRetention) + } else { + r0 = ret.Get(0).(admin.UpdateSnapshotRetentionApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateSnapshotRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSnapshotRetention' +type CloudBackupsApi_UpdateSnapshotRetention_Call struct { + *mock.Call +} + +// UpdateSnapshotRetention is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +// - backupSnapshotRetention *admin.BackupSnapshotRetention +func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetention(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}, backupSnapshotRetention interface{}) *CloudBackupsApi_UpdateSnapshotRetention_Call { + return &CloudBackupsApi_UpdateSnapshotRetention_Call{Call: _e.mock.On("UpdateSnapshotRetention", ctx, groupId, clusterName, snapshotId, backupSnapshotRetention)} +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshotRetention *admin.BackupSnapshotRetention)) *CloudBackupsApi_UpdateSnapshotRetention_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.BackupSnapshotRetention)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) Return(_a0 admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetention_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupSnapshotRetention) admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetention_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSnapshotRetentionExecute provides a mock function with given fields: r +func (_m *CloudBackupsApi) UpdateSnapshotRetentionExecute(r admin.UpdateSnapshotRetentionApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateSnapshotRetentionExecute") + } + + var r0 *admin.DiskBackupReplicaSet + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateSnapshotRetentionApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateSnapshotRetentionApiRequest) *admin.DiskBackupReplicaSet); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DiskBackupReplicaSet) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateSnapshotRetentionApiRequest) *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.UpdateSnapshotRetentionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudBackupsApi_UpdateSnapshotRetentionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSnapshotRetentionExecute' +type CloudBackupsApi_UpdateSnapshotRetentionExecute_Call struct { + *mock.Call +} + +// UpdateSnapshotRetentionExecute is a helper method to define mock.On call +// - r admin.UpdateSnapshotRetentionApiRequest +func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetentionExecute(r interface{}) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call { + return &CloudBackupsApi_UpdateSnapshotRetentionExecute_Call{Call: _e.mock.On("UpdateSnapshotRetentionExecute", r)} +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call) Run(run func(r admin.UpdateSnapshotRetentionApiRequest)) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateSnapshotRetentionApiRequest)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call) Return(_a0 *admin.DiskBackupReplicaSet, _a1 *http.Response, _a2 error) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call) RunAndReturn(run func(admin.UpdateSnapshotRetentionApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSnapshotRetentionWithParams provides a mock function with given fields: ctx, args +func (_m *CloudBackupsApi) UpdateSnapshotRetentionWithParams(ctx context.Context, args *admin.UpdateSnapshotRetentionApiParams) admin.UpdateSnapshotRetentionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateSnapshotRetentionWithParams") + } + + var r0 admin.UpdateSnapshotRetentionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateSnapshotRetentionApiParams) admin.UpdateSnapshotRetentionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateSnapshotRetentionApiRequest) + } + + return r0 +} + +// CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSnapshotRetentionWithParams' +type CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call struct { + *mock.Call +} + +// UpdateSnapshotRetentionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateSnapshotRetentionApiParams +func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetentionWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call { + return &CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call{Call: _e.mock.On("UpdateSnapshotRetentionWithParams", ctx, args)} +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateSnapshotRetentionApiParams)) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateSnapshotRetentionApiParams)) + }) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call) Return(_a0 admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateSnapshotRetentionApiParams) admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewCloudBackupsApi creates a new instance of CloudBackupsApi. 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 NewCloudBackupsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *CloudBackupsApi { + mock := &CloudBackupsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/cloud_migration_service_api.go b/mockadmin/cloud_migration_service_api.go new file mode 100644 index 000000000..7f420f9cc --- /dev/null +++ b/mockadmin/cloud_migration_service_api.go @@ -0,0 +1,1325 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// CloudMigrationServiceApi is an autogenerated mock type for the CloudMigrationServiceApi type +type CloudMigrationServiceApi struct { + mock.Mock +} + +type CloudMigrationServiceApi_Expecter struct { + mock *mock.Mock +} + +func (_m *CloudMigrationServiceApi) EXPECT() *CloudMigrationServiceApi_Expecter { + return &CloudMigrationServiceApi_Expecter{mock: &_m.Mock} +} + +// CreateLinkToken provides a mock function with given fields: ctx, orgId, targetOrgRequest +func (_m *CloudMigrationServiceApi) CreateLinkToken(ctx context.Context, orgId string, targetOrgRequest *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest { + ret := _m.Called(ctx, orgId, targetOrgRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateLinkToken") + } + + var r0 admin.CreateLinkTokenApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest); ok { + r0 = rf(ctx, orgId, targetOrgRequest) + } else { + r0 = ret.Get(0).(admin.CreateLinkTokenApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CreateLinkToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkToken' +type CloudMigrationServiceApi_CreateLinkToken_Call struct { + *mock.Call +} + +// CreateLinkToken is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - targetOrgRequest *admin.TargetOrgRequest +func (_e *CloudMigrationServiceApi_Expecter) CreateLinkToken(ctx interface{}, orgId interface{}, targetOrgRequest interface{}) *CloudMigrationServiceApi_CreateLinkToken_Call { + return &CloudMigrationServiceApi_CreateLinkToken_Call{Call: _e.mock.On("CreateLinkToken", ctx, orgId, targetOrgRequest)} +} + +func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) Run(run func(ctx context.Context, orgId string, targetOrgRequest *admin.TargetOrgRequest)) *CloudMigrationServiceApi_CreateLinkToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.TargetOrgRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) Return(_a0 admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkToken_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) RunAndReturn(run func(context.Context, string, *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkToken_Call { + _c.Call.Return(run) + return _c +} + +// CreateLinkTokenExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) CreateLinkTokenExecute(r admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateLinkTokenExecute") + } + + var r0 *admin.TargetOrg + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateLinkTokenApiRequest) *admin.TargetOrg); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.TargetOrg) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateLinkTokenApiRequest) *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.CreateLinkTokenApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_CreateLinkTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkTokenExecute' +type CloudMigrationServiceApi_CreateLinkTokenExecute_Call struct { + *mock.Call +} + +// CreateLinkTokenExecute is a helper method to define mock.On call +// - r admin.CreateLinkTokenApiRequest +func (_e *CloudMigrationServiceApi_Expecter) CreateLinkTokenExecute(r interface{}) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call { + return &CloudMigrationServiceApi_CreateLinkTokenExecute_Call{Call: _e.mock.On("CreateLinkTokenExecute", r)} +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) Run(run func(r admin.CreateLinkTokenApiRequest)) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateLinkTokenApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) Return(_a0 *admin.TargetOrg, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) RunAndReturn(run func(admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error)) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateLinkTokenWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) CreateLinkTokenWithParams(ctx context.Context, args *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateLinkTokenWithParams") + } + + var r0 admin.CreateLinkTokenApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateLinkTokenApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CreateLinkTokenWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkTokenWithParams' +type CloudMigrationServiceApi_CreateLinkTokenWithParams_Call struct { + *mock.Call +} + +// CreateLinkTokenWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateLinkTokenApiParams +func (_e *CloudMigrationServiceApi_Expecter) CreateLinkTokenWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call { + return &CloudMigrationServiceApi_CreateLinkTokenWithParams_Call{Call: _e.mock.On("CreateLinkTokenWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateLinkTokenApiParams)) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateLinkTokenApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) Return(_a0 admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreatePushMigration provides a mock function with given fields: ctx, groupId, liveMigrationRequest +func (_m *CloudMigrationServiceApi) CreatePushMigration(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest { + ret := _m.Called(ctx, groupId, liveMigrationRequest) + + if len(ret) == 0 { + panic("no return value specified for CreatePushMigration") + } + + var r0 admin.CreatePushMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest); ok { + r0 = rf(ctx, groupId, liveMigrationRequest) + } else { + r0 = ret.Get(0).(admin.CreatePushMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CreatePushMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigration' +type CloudMigrationServiceApi_CreatePushMigration_Call struct { + *mock.Call +} + +// CreatePushMigration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - liveMigrationRequest *admin.LiveMigrationRequest +func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigration(ctx interface{}, groupId interface{}, liveMigrationRequest interface{}) *CloudMigrationServiceApi_CreatePushMigration_Call { + return &CloudMigrationServiceApi_CreatePushMigration_Call{Call: _e.mock.On("CreatePushMigration", ctx, groupId, liveMigrationRequest)} +} + +func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest)) *CloudMigrationServiceApi_CreatePushMigration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.LiveMigrationRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) Return(_a0 admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) RunAndReturn(run func(context.Context, string, *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigration_Call { + _c.Call.Return(run) + return _c +} + +// CreatePushMigrationExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) CreatePushMigrationExecute(r admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePushMigrationExecute") + } + + var r0 *admin.LiveMigrationResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePushMigrationApiRequest) *admin.LiveMigrationResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LiveMigrationResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePushMigrationApiRequest) *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.CreatePushMigrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_CreatePushMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigrationExecute' +type CloudMigrationServiceApi_CreatePushMigrationExecute_Call struct { + *mock.Call +} + +// CreatePushMigrationExecute is a helper method to define mock.On call +// - r admin.CreatePushMigrationApiRequest +func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigrationExecute(r interface{}) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call { + return &CloudMigrationServiceApi_CreatePushMigrationExecute_Call{Call: _e.mock.On("CreatePushMigrationExecute", r)} +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) Run(run func(r admin.CreatePushMigrationApiRequest)) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePushMigrationApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) Return(_a0 *admin.LiveMigrationResponse, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) RunAndReturn(run func(admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePushMigrationWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) CreatePushMigrationWithParams(ctx context.Context, args *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePushMigrationWithParams") + } + + var r0 admin.CreatePushMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePushMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CreatePushMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigrationWithParams' +type CloudMigrationServiceApi_CreatePushMigrationWithParams_Call struct { + *mock.Call +} + +// CreatePushMigrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePushMigrationApiParams +func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call { + return &CloudMigrationServiceApi_CreatePushMigrationWithParams_Call{Call: _e.mock.On("CreatePushMigrationWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePushMigrationApiParams)) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePushMigrationApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) Return(_a0 admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CutoverMigration provides a mock function with given fields: ctx, groupId, liveMigrationId +func (_m *CloudMigrationServiceApi) CutoverMigration(ctx context.Context, groupId string, liveMigrationId string) admin.CutoverMigrationApiRequest { + ret := _m.Called(ctx, groupId, liveMigrationId) + + if len(ret) == 0 { + panic("no return value specified for CutoverMigration") + } + + var r0 admin.CutoverMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.CutoverMigrationApiRequest); ok { + r0 = rf(ctx, groupId, liveMigrationId) + } else { + r0 = ret.Get(0).(admin.CutoverMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CutoverMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigration' +type CloudMigrationServiceApi_CutoverMigration_Call struct { + *mock.Call +} + +// CutoverMigration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - liveMigrationId string +func (_e *CloudMigrationServiceApi_Expecter) CutoverMigration(ctx interface{}, groupId interface{}, liveMigrationId interface{}) *CloudMigrationServiceApi_CutoverMigration_Call { + return &CloudMigrationServiceApi_CutoverMigration_Call{Call: _e.mock.On("CutoverMigration", ctx, groupId, liveMigrationId)} +} + +func (_c *CloudMigrationServiceApi_CutoverMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationId string)) *CloudMigrationServiceApi_CutoverMigration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigration_Call) Return(_a0 admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigration_Call) RunAndReturn(run func(context.Context, string, string) admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigration_Call { + _c.Call.Return(run) + return _c +} + +// CutoverMigrationExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) CutoverMigrationExecute(r admin.CutoverMigrationApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CutoverMigrationExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.CutoverMigrationApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CutoverMigrationApiRequest) *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.CutoverMigrationApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudMigrationServiceApi_CutoverMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigrationExecute' +type CloudMigrationServiceApi_CutoverMigrationExecute_Call struct { + *mock.Call +} + +// CutoverMigrationExecute is a helper method to define mock.On call +// - r admin.CutoverMigrationApiRequest +func (_e *CloudMigrationServiceApi_Expecter) CutoverMigrationExecute(r interface{}) *CloudMigrationServiceApi_CutoverMigrationExecute_Call { + return &CloudMigrationServiceApi_CutoverMigrationExecute_Call{Call: _e.mock.On("CutoverMigrationExecute", r)} +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) Run(run func(r admin.CutoverMigrationApiRequest)) *CloudMigrationServiceApi_CutoverMigrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CutoverMigrationApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) Return(_a0 *http.Response, _a1 error) *CloudMigrationServiceApi_CutoverMigrationExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) RunAndReturn(run func(admin.CutoverMigrationApiRequest) (*http.Response, error)) *CloudMigrationServiceApi_CutoverMigrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CutoverMigrationWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) CutoverMigrationWithParams(ctx context.Context, args *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CutoverMigrationWithParams") + } + + var r0 admin.CutoverMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CutoverMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_CutoverMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigrationWithParams' +type CloudMigrationServiceApi_CutoverMigrationWithParams_Call struct { + *mock.Call +} + +// CutoverMigrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CutoverMigrationApiParams +func (_e *CloudMigrationServiceApi_Expecter) CutoverMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call { + return &CloudMigrationServiceApi_CutoverMigrationWithParams_Call{Call: _e.mock.On("CutoverMigrationWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.CutoverMigrationApiParams)) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CutoverMigrationApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) Return(_a0 admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLinkToken provides a mock function with given fields: ctx, orgId +func (_m *CloudMigrationServiceApi) DeleteLinkToken(ctx context.Context, orgId string) admin.DeleteLinkTokenApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for DeleteLinkToken") + } + + var r0 admin.DeleteLinkTokenApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteLinkTokenApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.DeleteLinkTokenApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_DeleteLinkToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkToken' +type CloudMigrationServiceApi_DeleteLinkToken_Call struct { + *mock.Call +} + +// DeleteLinkToken is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkToken(ctx interface{}, orgId interface{}) *CloudMigrationServiceApi_DeleteLinkToken_Call { + return &CloudMigrationServiceApi_DeleteLinkToken_Call{Call: _e.mock.On("DeleteLinkToken", ctx, orgId)} +} + +func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) Run(run func(ctx context.Context, orgId string)) *CloudMigrationServiceApi_DeleteLinkToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) Return(_a0 admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkToken_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) RunAndReturn(run func(context.Context, string) admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkToken_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLinkTokenExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) DeleteLinkTokenExecute(r admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteLinkTokenExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteLinkTokenApiRequest) 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.DeleteLinkTokenApiRequest) *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.DeleteLinkTokenApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_DeleteLinkTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkTokenExecute' +type CloudMigrationServiceApi_DeleteLinkTokenExecute_Call struct { + *mock.Call +} + +// DeleteLinkTokenExecute is a helper method to define mock.On call +// - r admin.DeleteLinkTokenApiRequest +func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkTokenExecute(r interface{}) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call { + return &CloudMigrationServiceApi_DeleteLinkTokenExecute_Call{Call: _e.mock.On("DeleteLinkTokenExecute", r)} +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) Run(run func(r admin.DeleteLinkTokenApiRequest)) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteLinkTokenApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) RunAndReturn(run func(admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error)) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLinkTokenWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) DeleteLinkTokenWithParams(ctx context.Context, args *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteLinkTokenWithParams") + } + + var r0 admin.DeleteLinkTokenApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteLinkTokenApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkTokenWithParams' +type CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call struct { + *mock.Call +} + +// DeleteLinkTokenWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteLinkTokenApiParams +func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkTokenWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call { + return &CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call{Call: _e.mock.On("DeleteLinkTokenWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteLinkTokenApiParams)) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteLinkTokenApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) Return(_a0 admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPushMigration provides a mock function with given fields: ctx, groupId, liveMigrationId +func (_m *CloudMigrationServiceApi) GetPushMigration(ctx context.Context, groupId string, liveMigrationId string) admin.GetPushMigrationApiRequest { + ret := _m.Called(ctx, groupId, liveMigrationId) + + if len(ret) == 0 { + panic("no return value specified for GetPushMigration") + } + + var r0 admin.GetPushMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetPushMigrationApiRequest); ok { + r0 = rf(ctx, groupId, liveMigrationId) + } else { + r0 = ret.Get(0).(admin.GetPushMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_GetPushMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigration' +type CloudMigrationServiceApi_GetPushMigration_Call struct { + *mock.Call +} + +// GetPushMigration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - liveMigrationId string +func (_e *CloudMigrationServiceApi_Expecter) GetPushMigration(ctx interface{}, groupId interface{}, liveMigrationId interface{}) *CloudMigrationServiceApi_GetPushMigration_Call { + return &CloudMigrationServiceApi_GetPushMigration_Call{Call: _e.mock.On("GetPushMigration", ctx, groupId, liveMigrationId)} +} + +func (_c *CloudMigrationServiceApi_GetPushMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationId string)) *CloudMigrationServiceApi_GetPushMigration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigration_Call) Return(_a0 admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigration_Call) RunAndReturn(run func(context.Context, string, string) admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigration_Call { + _c.Call.Return(run) + return _c +} + +// GetPushMigrationExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) GetPushMigrationExecute(r admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPushMigrationExecute") + } + + var r0 *admin.LiveMigrationResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPushMigrationApiRequest) *admin.LiveMigrationResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LiveMigrationResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPushMigrationApiRequest) *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.GetPushMigrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_GetPushMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigrationExecute' +type CloudMigrationServiceApi_GetPushMigrationExecute_Call struct { + *mock.Call +} + +// GetPushMigrationExecute is a helper method to define mock.On call +// - r admin.GetPushMigrationApiRequest +func (_e *CloudMigrationServiceApi_Expecter) GetPushMigrationExecute(r interface{}) *CloudMigrationServiceApi_GetPushMigrationExecute_Call { + return &CloudMigrationServiceApi_GetPushMigrationExecute_Call{Call: _e.mock.On("GetPushMigrationExecute", r)} +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) Run(run func(r admin.GetPushMigrationApiRequest)) *CloudMigrationServiceApi_GetPushMigrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPushMigrationApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) Return(_a0 *admin.LiveMigrationResponse, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_GetPushMigrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) RunAndReturn(run func(admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)) *CloudMigrationServiceApi_GetPushMigrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPushMigrationWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) GetPushMigrationWithParams(ctx context.Context, args *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPushMigrationWithParams") + } + + var r0 admin.GetPushMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPushMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_GetPushMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigrationWithParams' +type CloudMigrationServiceApi_GetPushMigrationWithParams_Call struct { + *mock.Call +} + +// GetPushMigrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPushMigrationApiParams +func (_e *CloudMigrationServiceApi_Expecter) GetPushMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call { + return &CloudMigrationServiceApi_GetPushMigrationWithParams_Call{Call: _e.mock.On("GetPushMigrationWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPushMigrationApiParams)) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPushMigrationApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) Return(_a0 admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetValidationStatus provides a mock function with given fields: ctx, groupId, validationId +func (_m *CloudMigrationServiceApi) GetValidationStatus(ctx context.Context, groupId string, validationId string) admin.GetValidationStatusApiRequest { + ret := _m.Called(ctx, groupId, validationId) + + if len(ret) == 0 { + panic("no return value specified for GetValidationStatus") + } + + var r0 admin.GetValidationStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetValidationStatusApiRequest); ok { + r0 = rf(ctx, groupId, validationId) + } else { + r0 = ret.Get(0).(admin.GetValidationStatusApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_GetValidationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatus' +type CloudMigrationServiceApi_GetValidationStatus_Call struct { + *mock.Call +} + +// GetValidationStatus is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - validationId string +func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatus(ctx interface{}, groupId interface{}, validationId interface{}) *CloudMigrationServiceApi_GetValidationStatus_Call { + return &CloudMigrationServiceApi_GetValidationStatus_Call{Call: _e.mock.On("GetValidationStatus", ctx, groupId, validationId)} +} + +func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) Run(run func(ctx context.Context, groupId string, validationId string)) *CloudMigrationServiceApi_GetValidationStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) Return(_a0 admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetValidationStatusExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) GetValidationStatusExecute(r admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetValidationStatusExecute") + } + + var r0 *admin.LiveImportValidation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetValidationStatusApiRequest) *admin.LiveImportValidation); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LiveImportValidation) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetValidationStatusApiRequest) *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.GetValidationStatusApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_GetValidationStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatusExecute' +type CloudMigrationServiceApi_GetValidationStatusExecute_Call struct { + *mock.Call +} + +// GetValidationStatusExecute is a helper method to define mock.On call +// - r admin.GetValidationStatusApiRequest +func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatusExecute(r interface{}) *CloudMigrationServiceApi_GetValidationStatusExecute_Call { + return &CloudMigrationServiceApi_GetValidationStatusExecute_Call{Call: _e.mock.On("GetValidationStatusExecute", r)} +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) Run(run func(r admin.GetValidationStatusApiRequest)) *CloudMigrationServiceApi_GetValidationStatusExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetValidationStatusApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) Return(_a0 *admin.LiveImportValidation, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_GetValidationStatusExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) RunAndReturn(run func(admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error)) *CloudMigrationServiceApi_GetValidationStatusExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetValidationStatusWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) GetValidationStatusWithParams(ctx context.Context, args *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetValidationStatusWithParams") + } + + var r0 admin.GetValidationStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetValidationStatusApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_GetValidationStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatusWithParams' +type CloudMigrationServiceApi_GetValidationStatusWithParams_Call struct { + *mock.Call +} + +// GetValidationStatusWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetValidationStatusApiParams +func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatusWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call { + return &CloudMigrationServiceApi_GetValidationStatusWithParams_Call{Call: _e.mock.On("GetValidationStatusWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetValidationStatusApiParams)) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetValidationStatusApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) Return(_a0 admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSourceProjects provides a mock function with given fields: ctx, orgId +func (_m *CloudMigrationServiceApi) ListSourceProjects(ctx context.Context, orgId string) admin.ListSourceProjectsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListSourceProjects") + } + + var r0 admin.ListSourceProjectsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListSourceProjectsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListSourceProjectsApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_ListSourceProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjects' +type CloudMigrationServiceApi_ListSourceProjects_Call struct { + *mock.Call +} + +// ListSourceProjects is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjects(ctx interface{}, orgId interface{}) *CloudMigrationServiceApi_ListSourceProjects_Call { + return &CloudMigrationServiceApi_ListSourceProjects_Call{Call: _e.mock.On("ListSourceProjects", ctx, orgId)} +} + +func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) Run(run func(ctx context.Context, orgId string)) *CloudMigrationServiceApi_ListSourceProjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) Return(_a0 admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) RunAndReturn(run func(context.Context, string) admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjects_Call { + _c.Call.Return(run) + return _c +} + +// ListSourceProjectsExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) ListSourceProjectsExecute(r admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSourceProjectsExecute") + } + + var r0 []admin.LiveImportAvailableProject + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSourceProjectsApiRequest) []admin.LiveImportAvailableProject); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.LiveImportAvailableProject) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSourceProjectsApiRequest) *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.ListSourceProjectsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_ListSourceProjectsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjectsExecute' +type CloudMigrationServiceApi_ListSourceProjectsExecute_Call struct { + *mock.Call +} + +// ListSourceProjectsExecute is a helper method to define mock.On call +// - r admin.ListSourceProjectsApiRequest +func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjectsExecute(r interface{}) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call { + return &CloudMigrationServiceApi_ListSourceProjectsExecute_Call{Call: _e.mock.On("ListSourceProjectsExecute", r)} +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) Run(run func(r admin.ListSourceProjectsApiRequest)) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSourceProjectsApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) Return(_a0 []admin.LiveImportAvailableProject, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) RunAndReturn(run func(admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error)) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSourceProjectsWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) ListSourceProjectsWithParams(ctx context.Context, args *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSourceProjectsWithParams") + } + + var r0 admin.ListSourceProjectsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSourceProjectsApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_ListSourceProjectsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjectsWithParams' +type CloudMigrationServiceApi_ListSourceProjectsWithParams_Call struct { + *mock.Call +} + +// ListSourceProjectsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSourceProjectsApiParams +func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjectsWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call { + return &CloudMigrationServiceApi_ListSourceProjectsWithParams_Call{Call: _e.mock.On("ListSourceProjectsWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSourceProjectsApiParams)) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSourceProjectsApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) Return(_a0 admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ValidateMigration provides a mock function with given fields: ctx, groupId, liveMigrationRequest +func (_m *CloudMigrationServiceApi) ValidateMigration(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest { + ret := _m.Called(ctx, groupId, liveMigrationRequest) + + if len(ret) == 0 { + panic("no return value specified for ValidateMigration") + } + + var r0 admin.ValidateMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest); ok { + r0 = rf(ctx, groupId, liveMigrationRequest) + } else { + r0 = ret.Get(0).(admin.ValidateMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_ValidateMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigration' +type CloudMigrationServiceApi_ValidateMigration_Call struct { + *mock.Call +} + +// ValidateMigration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - liveMigrationRequest *admin.LiveMigrationRequest +func (_e *CloudMigrationServiceApi_Expecter) ValidateMigration(ctx interface{}, groupId interface{}, liveMigrationRequest interface{}) *CloudMigrationServiceApi_ValidateMigration_Call { + return &CloudMigrationServiceApi_ValidateMigration_Call{Call: _e.mock.On("ValidateMigration", ctx, groupId, liveMigrationRequest)} +} + +func (_c *CloudMigrationServiceApi_ValidateMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest)) *CloudMigrationServiceApi_ValidateMigration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.LiveMigrationRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigration_Call) Return(_a0 admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigration_Call) RunAndReturn(run func(context.Context, string, *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigration_Call { + _c.Call.Return(run) + return _c +} + +// ValidateMigrationExecute provides a mock function with given fields: r +func (_m *CloudMigrationServiceApi) ValidateMigrationExecute(r admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ValidateMigrationExecute") + } + + var r0 *admin.LiveImportValidation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ValidateMigrationApiRequest) *admin.LiveImportValidation); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LiveImportValidation) + } + } + + if rf, ok := ret.Get(1).(func(admin.ValidateMigrationApiRequest) *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.ValidateMigrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudMigrationServiceApi_ValidateMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigrationExecute' +type CloudMigrationServiceApi_ValidateMigrationExecute_Call struct { + *mock.Call +} + +// ValidateMigrationExecute is a helper method to define mock.On call +// - r admin.ValidateMigrationApiRequest +func (_e *CloudMigrationServiceApi_Expecter) ValidateMigrationExecute(r interface{}) *CloudMigrationServiceApi_ValidateMigrationExecute_Call { + return &CloudMigrationServiceApi_ValidateMigrationExecute_Call{Call: _e.mock.On("ValidateMigrationExecute", r)} +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) Run(run func(r admin.ValidateMigrationApiRequest)) *CloudMigrationServiceApi_ValidateMigrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ValidateMigrationApiRequest)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) Return(_a0 *admin.LiveImportValidation, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_ValidateMigrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) RunAndReturn(run func(admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error)) *CloudMigrationServiceApi_ValidateMigrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// ValidateMigrationWithParams provides a mock function with given fields: ctx, args +func (_m *CloudMigrationServiceApi) ValidateMigrationWithParams(ctx context.Context, args *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ValidateMigrationWithParams") + } + + var r0 admin.ValidateMigrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ValidateMigrationApiRequest) + } + + return r0 +} + +// CloudMigrationServiceApi_ValidateMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigrationWithParams' +type CloudMigrationServiceApi_ValidateMigrationWithParams_Call struct { + *mock.Call +} + +// ValidateMigrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ValidateMigrationApiParams +func (_e *CloudMigrationServiceApi_Expecter) ValidateMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call { + return &CloudMigrationServiceApi_ValidateMigrationWithParams_Call{Call: _e.mock.On("ValidateMigrationWithParams", ctx, args)} +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.ValidateMigrationApiParams)) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ValidateMigrationApiParams)) + }) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) Return(_a0 admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewCloudMigrationServiceApi creates a new instance of CloudMigrationServiceApi. 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 NewCloudMigrationServiceApi(t interface { + mock.TestingT + Cleanup(func()) +}) *CloudMigrationServiceApi { + mock := &CloudMigrationServiceApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/cloud_provider_access_api.go b/mockadmin/cloud_provider_access_api.go new file mode 100644 index 000000000..6d812735c --- /dev/null +++ b/mockadmin/cloud_provider_access_api.go @@ -0,0 +1,842 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// CloudProviderAccessApi is an autogenerated mock type for the CloudProviderAccessApi type +type CloudProviderAccessApi struct { + mock.Mock +} + +type CloudProviderAccessApi_Expecter struct { + mock *mock.Mock +} + +func (_m *CloudProviderAccessApi) EXPECT() *CloudProviderAccessApi_Expecter { + return &CloudProviderAccessApi_Expecter{mock: &_m.Mock} +} + +// AuthorizeCloudProviderAccessRole provides a mock function with given fields: ctx, groupId, roleId, cloudProviderAccessRole +func (_m *CloudProviderAccessApi) AuthorizeCloudProviderAccessRole(ctx context.Context, groupId string, roleId string, cloudProviderAccessRole *admin.CloudProviderAccessRole) admin.AuthorizeCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, groupId, roleId, cloudProviderAccessRole) + + if len(ret) == 0 { + panic("no return value specified for AuthorizeCloudProviderAccessRole") + } + + var r0 admin.AuthorizeCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.CloudProviderAccessRole) admin.AuthorizeCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, groupId, roleId, cloudProviderAccessRole) + } else { + r0 = ret.Get(0).(admin.AuthorizeCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeCloudProviderAccessRole' +type CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call struct { + *mock.Call +} + +// AuthorizeCloudProviderAccessRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - roleId string +// - cloudProviderAccessRole *admin.CloudProviderAccessRole +func (_e *CloudProviderAccessApi_Expecter) AuthorizeCloudProviderAccessRole(ctx interface{}, groupId interface{}, roleId interface{}, cloudProviderAccessRole interface{}) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call { + return &CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call{Call: _e.mock.On("AuthorizeCloudProviderAccessRole", ctx, groupId, roleId, cloudProviderAccessRole)} +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call) Run(run func(ctx context.Context, groupId string, roleId string, cloudProviderAccessRole *admin.CloudProviderAccessRole)) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.CloudProviderAccessRole)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call) Return(_a0 admin.AuthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call) RunAndReturn(run func(context.Context, string, string, *admin.CloudProviderAccessRole) admin.AuthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRole_Call { + _c.Call.Return(run) + return _c +} + +// AuthorizeCloudProviderAccessRoleExecute provides a mock function with given fields: r +func (_m *CloudProviderAccessApi) AuthorizeCloudProviderAccessRoleExecute(r admin.AuthorizeCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for AuthorizeCloudProviderAccessRoleExecute") + } + + var r0 *admin.CloudProviderAccessRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.AuthorizeCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.AuthorizeCloudProviderAccessRoleApiRequest) *admin.CloudProviderAccessRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderAccessRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.AuthorizeCloudProviderAccessRoleApiRequest) *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.AuthorizeCloudProviderAccessRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeCloudProviderAccessRoleExecute' +type CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call struct { + *mock.Call +} + +// AuthorizeCloudProviderAccessRoleExecute is a helper method to define mock.On call +// - r admin.AuthorizeCloudProviderAccessRoleApiRequest +func (_e *CloudProviderAccessApi_Expecter) AuthorizeCloudProviderAccessRoleExecute(r interface{}) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call { + return &CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call{Call: _e.mock.On("AuthorizeCloudProviderAccessRoleExecute", r)} +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call) Run(run func(r admin.AuthorizeCloudProviderAccessRoleApiRequest)) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.AuthorizeCloudProviderAccessRoleApiRequest)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call) Return(_a0 *admin.CloudProviderAccessRole, _a1 *http.Response, _a2 error) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call) RunAndReturn(run func(admin.AuthorizeCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// AuthorizeCloudProviderAccessRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudProviderAccessApi) AuthorizeCloudProviderAccessRoleWithParams(ctx context.Context, args *admin.AuthorizeCloudProviderAccessRoleApiParams) admin.AuthorizeCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for AuthorizeCloudProviderAccessRoleWithParams") + } + + var r0 admin.AuthorizeCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.AuthorizeCloudProviderAccessRoleApiParams) admin.AuthorizeCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.AuthorizeCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeCloudProviderAccessRoleWithParams' +type CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call struct { + *mock.Call +} + +// AuthorizeCloudProviderAccessRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.AuthorizeCloudProviderAccessRoleApiParams +func (_e *CloudProviderAccessApi_Expecter) AuthorizeCloudProviderAccessRoleWithParams(ctx interface{}, args interface{}) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call { + return &CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call{Call: _e.mock.On("AuthorizeCloudProviderAccessRoleWithParams", ctx, args)} +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.AuthorizeCloudProviderAccessRoleApiParams)) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.AuthorizeCloudProviderAccessRoleApiParams)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call) Return(_a0 admin.AuthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.AuthorizeCloudProviderAccessRoleApiParams) admin.AuthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_AuthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateCloudProviderAccessRole provides a mock function with given fields: ctx, groupId, cloudProviderAccessRole +func (_m *CloudProviderAccessApi) CreateCloudProviderAccessRole(ctx context.Context, groupId string, cloudProviderAccessRole *admin.CloudProviderAccessRole) admin.CreateCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, groupId, cloudProviderAccessRole) + + if len(ret) == 0 { + panic("no return value specified for CreateCloudProviderAccessRole") + } + + var r0 admin.CreateCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CloudProviderAccessRole) admin.CreateCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, groupId, cloudProviderAccessRole) + } else { + r0 = ret.Get(0).(admin.CreateCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_CreateCloudProviderAccessRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCloudProviderAccessRole' +type CloudProviderAccessApi_CreateCloudProviderAccessRole_Call struct { + *mock.Call +} + +// CreateCloudProviderAccessRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProviderAccessRole *admin.CloudProviderAccessRole +func (_e *CloudProviderAccessApi_Expecter) CreateCloudProviderAccessRole(ctx interface{}, groupId interface{}, cloudProviderAccessRole interface{}) *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call { + return &CloudProviderAccessApi_CreateCloudProviderAccessRole_Call{Call: _e.mock.On("CreateCloudProviderAccessRole", ctx, groupId, cloudProviderAccessRole)} +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call) Run(run func(ctx context.Context, groupId string, cloudProviderAccessRole *admin.CloudProviderAccessRole)) *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CloudProviderAccessRole)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call) Return(_a0 admin.CreateCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call) RunAndReturn(run func(context.Context, string, *admin.CloudProviderAccessRole) admin.CreateCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_CreateCloudProviderAccessRole_Call { + _c.Call.Return(run) + return _c +} + +// CreateCloudProviderAccessRoleExecute provides a mock function with given fields: r +func (_m *CloudProviderAccessApi) CreateCloudProviderAccessRoleExecute(r admin.CreateCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateCloudProviderAccessRoleExecute") + } + + var r0 *admin.CloudProviderAccessRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateCloudProviderAccessRoleApiRequest) *admin.CloudProviderAccessRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderAccessRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateCloudProviderAccessRoleApiRequest) *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.CreateCloudProviderAccessRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCloudProviderAccessRoleExecute' +type CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call struct { + *mock.Call +} + +// CreateCloudProviderAccessRoleExecute is a helper method to define mock.On call +// - r admin.CreateCloudProviderAccessRoleApiRequest +func (_e *CloudProviderAccessApi_Expecter) CreateCloudProviderAccessRoleExecute(r interface{}) *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call { + return &CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call{Call: _e.mock.On("CreateCloudProviderAccessRoleExecute", r)} +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call) Run(run func(r admin.CreateCloudProviderAccessRoleApiRequest)) *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateCloudProviderAccessRoleApiRequest)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call) Return(_a0 *admin.CloudProviderAccessRole, _a1 *http.Response, _a2 error) *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call) RunAndReturn(run func(admin.CreateCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)) *CloudProviderAccessApi_CreateCloudProviderAccessRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateCloudProviderAccessRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudProviderAccessApi) CreateCloudProviderAccessRoleWithParams(ctx context.Context, args *admin.CreateCloudProviderAccessRoleApiParams) admin.CreateCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateCloudProviderAccessRoleWithParams") + } + + var r0 admin.CreateCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateCloudProviderAccessRoleApiParams) admin.CreateCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCloudProviderAccessRoleWithParams' +type CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call struct { + *mock.Call +} + +// CreateCloudProviderAccessRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateCloudProviderAccessRoleApiParams +func (_e *CloudProviderAccessApi_Expecter) CreateCloudProviderAccessRoleWithParams(ctx interface{}, args interface{}) *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call { + return &CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call{Call: _e.mock.On("CreateCloudProviderAccessRoleWithParams", ctx, args)} +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateCloudProviderAccessRoleApiParams)) *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateCloudProviderAccessRoleApiParams)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call) Return(_a0 admin.CreateCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateCloudProviderAccessRoleApiParams) admin.CreateCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_CreateCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeauthorizeCloudProviderAccessRole provides a mock function with given fields: ctx, groupId, cloudProvider, roleId +func (_m *CloudProviderAccessApi) DeauthorizeCloudProviderAccessRole(ctx context.Context, groupId string, cloudProvider string, roleId string) admin.DeauthorizeCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, roleId) + + if len(ret) == 0 { + panic("no return value specified for DeauthorizeCloudProviderAccessRole") + } + + var r0 admin.DeauthorizeCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeauthorizeCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, roleId) + } else { + r0 = ret.Get(0).(admin.DeauthorizeCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeauthorizeCloudProviderAccessRole' +type CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call struct { + *mock.Call +} + +// DeauthorizeCloudProviderAccessRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - roleId string +func (_e *CloudProviderAccessApi_Expecter) DeauthorizeCloudProviderAccessRole(ctx interface{}, groupId interface{}, cloudProvider interface{}, roleId interface{}) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call { + return &CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call{Call: _e.mock.On("DeauthorizeCloudProviderAccessRole", ctx, groupId, cloudProvider, roleId)} +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, roleId string)) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_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 *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call) Return(_a0 admin.DeauthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeauthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRole_Call { + _c.Call.Return(run) + return _c +} + +// DeauthorizeCloudProviderAccessRoleExecute provides a mock function with given fields: r +func (_m *CloudProviderAccessApi) DeauthorizeCloudProviderAccessRoleExecute(r admin.DeauthorizeCloudProviderAccessRoleApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeauthorizeCloudProviderAccessRoleExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeauthorizeCloudProviderAccessRoleApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeauthorizeCloudProviderAccessRoleApiRequest) *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.DeauthorizeCloudProviderAccessRoleApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeauthorizeCloudProviderAccessRoleExecute' +type CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call struct { + *mock.Call +} + +// DeauthorizeCloudProviderAccessRoleExecute is a helper method to define mock.On call +// - r admin.DeauthorizeCloudProviderAccessRoleApiRequest +func (_e *CloudProviderAccessApi_Expecter) DeauthorizeCloudProviderAccessRoleExecute(r interface{}) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call { + return &CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call{Call: _e.mock.On("DeauthorizeCloudProviderAccessRoleExecute", r)} +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call) Run(run func(r admin.DeauthorizeCloudProviderAccessRoleApiRequest)) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeauthorizeCloudProviderAccessRoleApiRequest)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call) Return(_a0 *http.Response, _a1 error) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call) RunAndReturn(run func(admin.DeauthorizeCloudProviderAccessRoleApiRequest) (*http.Response, error)) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeauthorizeCloudProviderAccessRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudProviderAccessApi) DeauthorizeCloudProviderAccessRoleWithParams(ctx context.Context, args *admin.DeauthorizeCloudProviderAccessRoleApiParams) admin.DeauthorizeCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeauthorizeCloudProviderAccessRoleWithParams") + } + + var r0 admin.DeauthorizeCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeauthorizeCloudProviderAccessRoleApiParams) admin.DeauthorizeCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeauthorizeCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeauthorizeCloudProviderAccessRoleWithParams' +type CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call struct { + *mock.Call +} + +// DeauthorizeCloudProviderAccessRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeauthorizeCloudProviderAccessRoleApiParams +func (_e *CloudProviderAccessApi_Expecter) DeauthorizeCloudProviderAccessRoleWithParams(ctx interface{}, args interface{}) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call { + return &CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call{Call: _e.mock.On("DeauthorizeCloudProviderAccessRoleWithParams", ctx, args)} +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.DeauthorizeCloudProviderAccessRoleApiParams)) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeauthorizeCloudProviderAccessRoleApiParams)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call) Return(_a0 admin.DeauthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeauthorizeCloudProviderAccessRoleApiParams) admin.DeauthorizeCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_DeauthorizeCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetCloudProviderAccessRole provides a mock function with given fields: ctx, groupId, roleId +func (_m *CloudProviderAccessApi) GetCloudProviderAccessRole(ctx context.Context, groupId string, roleId string) admin.GetCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, groupId, roleId) + + if len(ret) == 0 { + panic("no return value specified for GetCloudProviderAccessRole") + } + + var r0 admin.GetCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, groupId, roleId) + } else { + r0 = ret.Get(0).(admin.GetCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_GetCloudProviderAccessRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCloudProviderAccessRole' +type CloudProviderAccessApi_GetCloudProviderAccessRole_Call struct { + *mock.Call +} + +// GetCloudProviderAccessRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - roleId string +func (_e *CloudProviderAccessApi_Expecter) GetCloudProviderAccessRole(ctx interface{}, groupId interface{}, roleId interface{}) *CloudProviderAccessApi_GetCloudProviderAccessRole_Call { + return &CloudProviderAccessApi_GetCloudProviderAccessRole_Call{Call: _e.mock.On("GetCloudProviderAccessRole", ctx, groupId, roleId)} +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRole_Call) Run(run func(ctx context.Context, groupId string, roleId string)) *CloudProviderAccessApi_GetCloudProviderAccessRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRole_Call) Return(_a0 admin.GetCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_GetCloudProviderAccessRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRole_Call) RunAndReturn(run func(context.Context, string, string) admin.GetCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_GetCloudProviderAccessRole_Call { + _c.Call.Return(run) + return _c +} + +// GetCloudProviderAccessRoleExecute provides a mock function with given fields: r +func (_m *CloudProviderAccessApi) GetCloudProviderAccessRoleExecute(r admin.GetCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetCloudProviderAccessRoleExecute") + } + + var r0 *admin.CloudProviderAccessRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetCloudProviderAccessRoleApiRequest) *admin.CloudProviderAccessRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderAccessRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetCloudProviderAccessRoleApiRequest) *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.GetCloudProviderAccessRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCloudProviderAccessRoleExecute' +type CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call struct { + *mock.Call +} + +// GetCloudProviderAccessRoleExecute is a helper method to define mock.On call +// - r admin.GetCloudProviderAccessRoleApiRequest +func (_e *CloudProviderAccessApi_Expecter) GetCloudProviderAccessRoleExecute(r interface{}) *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call { + return &CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call{Call: _e.mock.On("GetCloudProviderAccessRoleExecute", r)} +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call) Run(run func(r admin.GetCloudProviderAccessRoleApiRequest)) *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetCloudProviderAccessRoleApiRequest)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call) Return(_a0 *admin.CloudProviderAccessRole, _a1 *http.Response, _a2 error) *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call) RunAndReturn(run func(admin.GetCloudProviderAccessRoleApiRequest) (*admin.CloudProviderAccessRole, *http.Response, error)) *CloudProviderAccessApi_GetCloudProviderAccessRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetCloudProviderAccessRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CloudProviderAccessApi) GetCloudProviderAccessRoleWithParams(ctx context.Context, args *admin.GetCloudProviderAccessRoleApiParams) admin.GetCloudProviderAccessRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetCloudProviderAccessRoleWithParams") + } + + var r0 admin.GetCloudProviderAccessRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetCloudProviderAccessRoleApiParams) admin.GetCloudProviderAccessRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetCloudProviderAccessRoleApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCloudProviderAccessRoleWithParams' +type CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call struct { + *mock.Call +} + +// GetCloudProviderAccessRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetCloudProviderAccessRoleApiParams +func (_e *CloudProviderAccessApi_Expecter) GetCloudProviderAccessRoleWithParams(ctx interface{}, args interface{}) *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call { + return &CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call{Call: _e.mock.On("GetCloudProviderAccessRoleWithParams", ctx, args)} +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.GetCloudProviderAccessRoleApiParams)) *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetCloudProviderAccessRoleApiParams)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call) Return(_a0 admin.GetCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetCloudProviderAccessRoleApiParams) admin.GetCloudProviderAccessRoleApiRequest) *CloudProviderAccessApi_GetCloudProviderAccessRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListCloudProviderAccessRoles provides a mock function with given fields: ctx, groupId +func (_m *CloudProviderAccessApi) ListCloudProviderAccessRoles(ctx context.Context, groupId string) admin.ListCloudProviderAccessRolesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListCloudProviderAccessRoles") + } + + var r0 admin.ListCloudProviderAccessRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListCloudProviderAccessRolesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListCloudProviderAccessRolesApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_ListCloudProviderAccessRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderAccessRoles' +type CloudProviderAccessApi_ListCloudProviderAccessRoles_Call struct { + *mock.Call +} + +// ListCloudProviderAccessRoles is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *CloudProviderAccessApi_Expecter) ListCloudProviderAccessRoles(ctx interface{}, groupId interface{}) *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call { + return &CloudProviderAccessApi_ListCloudProviderAccessRoles_Call{Call: _e.mock.On("ListCloudProviderAccessRoles", ctx, groupId)} +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call) Run(run func(ctx context.Context, groupId string)) *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call) Return(_a0 admin.ListCloudProviderAccessRolesApiRequest) *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call) RunAndReturn(run func(context.Context, string) admin.ListCloudProviderAccessRolesApiRequest) *CloudProviderAccessApi_ListCloudProviderAccessRoles_Call { + _c.Call.Return(run) + return _c +} + +// ListCloudProviderAccessRolesExecute provides a mock function with given fields: r +func (_m *CloudProviderAccessApi) ListCloudProviderAccessRolesExecute(r admin.ListCloudProviderAccessRolesApiRequest) (*admin.CloudProviderAccessRoles, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListCloudProviderAccessRolesExecute") + } + + var r0 *admin.CloudProviderAccessRoles + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListCloudProviderAccessRolesApiRequest) (*admin.CloudProviderAccessRoles, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListCloudProviderAccessRolesApiRequest) *admin.CloudProviderAccessRoles); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderAccessRoles) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListCloudProviderAccessRolesApiRequest) *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.ListCloudProviderAccessRolesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderAccessRolesExecute' +type CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call struct { + *mock.Call +} + +// ListCloudProviderAccessRolesExecute is a helper method to define mock.On call +// - r admin.ListCloudProviderAccessRolesApiRequest +func (_e *CloudProviderAccessApi_Expecter) ListCloudProviderAccessRolesExecute(r interface{}) *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call { + return &CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call{Call: _e.mock.On("ListCloudProviderAccessRolesExecute", r)} +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call) Run(run func(r admin.ListCloudProviderAccessRolesApiRequest)) *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListCloudProviderAccessRolesApiRequest)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call) Return(_a0 *admin.CloudProviderAccessRoles, _a1 *http.Response, _a2 error) *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call) RunAndReturn(run func(admin.ListCloudProviderAccessRolesApiRequest) (*admin.CloudProviderAccessRoles, *http.Response, error)) *CloudProviderAccessApi_ListCloudProviderAccessRolesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListCloudProviderAccessRolesWithParams provides a mock function with given fields: ctx, args +func (_m *CloudProviderAccessApi) ListCloudProviderAccessRolesWithParams(ctx context.Context, args *admin.ListCloudProviderAccessRolesApiParams) admin.ListCloudProviderAccessRolesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListCloudProviderAccessRolesWithParams") + } + + var r0 admin.ListCloudProviderAccessRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListCloudProviderAccessRolesApiParams) admin.ListCloudProviderAccessRolesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListCloudProviderAccessRolesApiRequest) + } + + return r0 +} + +// CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCloudProviderAccessRolesWithParams' +type CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call struct { + *mock.Call +} + +// ListCloudProviderAccessRolesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListCloudProviderAccessRolesApiParams +func (_e *CloudProviderAccessApi_Expecter) ListCloudProviderAccessRolesWithParams(ctx interface{}, args interface{}) *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call { + return &CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call{Call: _e.mock.On("ListCloudProviderAccessRolesWithParams", ctx, args)} +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListCloudProviderAccessRolesApiParams)) *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListCloudProviderAccessRolesApiParams)) + }) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call) Return(_a0 admin.ListCloudProviderAccessRolesApiRequest) *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListCloudProviderAccessRolesApiParams) admin.ListCloudProviderAccessRolesApiRequest) *CloudProviderAccessApi_ListCloudProviderAccessRolesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewCloudProviderAccessApi creates a new instance of CloudProviderAccessApi. 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 NewCloudProviderAccessApi(t interface { + mock.TestingT + Cleanup(func()) +}) *CloudProviderAccessApi { + mock := &CloudProviderAccessApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/cluster_outage_simulation_api.go b/mockadmin/cluster_outage_simulation_api.go new file mode 100644 index 000000000..2b3de4b8d --- /dev/null +++ b/mockadmin/cluster_outage_simulation_api.go @@ -0,0 +1,527 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ClusterOutageSimulationApi is an autogenerated mock type for the ClusterOutageSimulationApi type +type ClusterOutageSimulationApi struct { + mock.Mock +} + +type ClusterOutageSimulationApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ClusterOutageSimulationApi) EXPECT() *ClusterOutageSimulationApi_Expecter { + return &ClusterOutageSimulationApi_Expecter{mock: &_m.Mock} +} + +// EndOutageSimulation provides a mock function with given fields: ctx, groupId, clusterName +func (_m *ClusterOutageSimulationApi) EndOutageSimulation(ctx context.Context, groupId string, clusterName string) admin.EndOutageSimulationApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for EndOutageSimulation") + } + + var r0 admin.EndOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.EndOutageSimulationApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.EndOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_EndOutageSimulation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndOutageSimulation' +type ClusterOutageSimulationApi_EndOutageSimulation_Call struct { + *mock.Call +} + +// EndOutageSimulation is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *ClusterOutageSimulationApi_Expecter) EndOutageSimulation(ctx interface{}, groupId interface{}, clusterName interface{}) *ClusterOutageSimulationApi_EndOutageSimulation_Call { + return &ClusterOutageSimulationApi_EndOutageSimulation_Call{Call: _e.mock.On("EndOutageSimulation", ctx, groupId, clusterName)} +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulation_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClusterOutageSimulationApi_EndOutageSimulation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulation_Call) Return(_a0 admin.EndOutageSimulationApiRequest) *ClusterOutageSimulationApi_EndOutageSimulation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulation_Call) RunAndReturn(run func(context.Context, string, string) admin.EndOutageSimulationApiRequest) *ClusterOutageSimulationApi_EndOutageSimulation_Call { + _c.Call.Return(run) + return _c +} + +// EndOutageSimulationExecute provides a mock function with given fields: r +func (_m *ClusterOutageSimulationApi) EndOutageSimulationExecute(r admin.EndOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for EndOutageSimulationExecute") + } + + var r0 *admin.ClusterOutageSimulation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.EndOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.EndOutageSimulationApiRequest) *admin.ClusterOutageSimulation); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ClusterOutageSimulation) + } + } + + if rf, ok := ret.Get(1).(func(admin.EndOutageSimulationApiRequest) *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.EndOutageSimulationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ClusterOutageSimulationApi_EndOutageSimulationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndOutageSimulationExecute' +type ClusterOutageSimulationApi_EndOutageSimulationExecute_Call struct { + *mock.Call +} + +// EndOutageSimulationExecute is a helper method to define mock.On call +// - r admin.EndOutageSimulationApiRequest +func (_e *ClusterOutageSimulationApi_Expecter) EndOutageSimulationExecute(r interface{}) *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call { + return &ClusterOutageSimulationApi_EndOutageSimulationExecute_Call{Call: _e.mock.On("EndOutageSimulationExecute", r)} +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call) Run(run func(r admin.EndOutageSimulationApiRequest)) *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.EndOutageSimulationApiRequest)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call) Return(_a0 *admin.ClusterOutageSimulation, _a1 *http.Response, _a2 error) *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call) RunAndReturn(run func(admin.EndOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)) *ClusterOutageSimulationApi_EndOutageSimulationExecute_Call { + _c.Call.Return(run) + return _c +} + +// EndOutageSimulationWithParams provides a mock function with given fields: ctx, args +func (_m *ClusterOutageSimulationApi) EndOutageSimulationWithParams(ctx context.Context, args *admin.EndOutageSimulationApiParams) admin.EndOutageSimulationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for EndOutageSimulationWithParams") + } + + var r0 admin.EndOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.EndOutageSimulationApiParams) admin.EndOutageSimulationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.EndOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndOutageSimulationWithParams' +type ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call struct { + *mock.Call +} + +// EndOutageSimulationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.EndOutageSimulationApiParams +func (_e *ClusterOutageSimulationApi_Expecter) EndOutageSimulationWithParams(ctx interface{}, args interface{}) *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call { + return &ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call{Call: _e.mock.On("EndOutageSimulationWithParams", ctx, args)} +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call) Run(run func(ctx context.Context, args *admin.EndOutageSimulationApiParams)) *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.EndOutageSimulationApiParams)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call) Return(_a0 admin.EndOutageSimulationApiRequest) *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call) RunAndReturn(run func(context.Context, *admin.EndOutageSimulationApiParams) admin.EndOutageSimulationApiRequest) *ClusterOutageSimulationApi_EndOutageSimulationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetOutageSimulation provides a mock function with given fields: ctx, groupId, clusterName +func (_m *ClusterOutageSimulationApi) GetOutageSimulation(ctx context.Context, groupId string, clusterName string) admin.GetOutageSimulationApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetOutageSimulation") + } + + var r0 admin.GetOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetOutageSimulationApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_GetOutageSimulation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutageSimulation' +type ClusterOutageSimulationApi_GetOutageSimulation_Call struct { + *mock.Call +} + +// GetOutageSimulation is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *ClusterOutageSimulationApi_Expecter) GetOutageSimulation(ctx interface{}, groupId interface{}, clusterName interface{}) *ClusterOutageSimulationApi_GetOutageSimulation_Call { + return &ClusterOutageSimulationApi_GetOutageSimulation_Call{Call: _e.mock.On("GetOutageSimulation", ctx, groupId, clusterName)} +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulation_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *ClusterOutageSimulationApi_GetOutageSimulation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulation_Call) Return(_a0 admin.GetOutageSimulationApiRequest) *ClusterOutageSimulationApi_GetOutageSimulation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulation_Call) RunAndReturn(run func(context.Context, string, string) admin.GetOutageSimulationApiRequest) *ClusterOutageSimulationApi_GetOutageSimulation_Call { + _c.Call.Return(run) + return _c +} + +// GetOutageSimulationExecute provides a mock function with given fields: r +func (_m *ClusterOutageSimulationApi) GetOutageSimulationExecute(r admin.GetOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOutageSimulationExecute") + } + + var r0 *admin.ClusterOutageSimulation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOutageSimulationApiRequest) *admin.ClusterOutageSimulation); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ClusterOutageSimulation) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetOutageSimulationApiRequest) *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.GetOutageSimulationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ClusterOutageSimulationApi_GetOutageSimulationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutageSimulationExecute' +type ClusterOutageSimulationApi_GetOutageSimulationExecute_Call struct { + *mock.Call +} + +// GetOutageSimulationExecute is a helper method to define mock.On call +// - r admin.GetOutageSimulationApiRequest +func (_e *ClusterOutageSimulationApi_Expecter) GetOutageSimulationExecute(r interface{}) *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call { + return &ClusterOutageSimulationApi_GetOutageSimulationExecute_Call{Call: _e.mock.On("GetOutageSimulationExecute", r)} +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call) Run(run func(r admin.GetOutageSimulationApiRequest)) *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOutageSimulationApiRequest)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call) Return(_a0 *admin.ClusterOutageSimulation, _a1 *http.Response, _a2 error) *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call) RunAndReturn(run func(admin.GetOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)) *ClusterOutageSimulationApi_GetOutageSimulationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOutageSimulationWithParams provides a mock function with given fields: ctx, args +func (_m *ClusterOutageSimulationApi) GetOutageSimulationWithParams(ctx context.Context, args *admin.GetOutageSimulationApiParams) admin.GetOutageSimulationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOutageSimulationWithParams") + } + + var r0 admin.GetOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOutageSimulationApiParams) admin.GetOutageSimulationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutageSimulationWithParams' +type ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call struct { + *mock.Call +} + +// GetOutageSimulationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOutageSimulationApiParams +func (_e *ClusterOutageSimulationApi_Expecter) GetOutageSimulationWithParams(ctx interface{}, args interface{}) *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call { + return &ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call{Call: _e.mock.On("GetOutageSimulationWithParams", ctx, args)} +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOutageSimulationApiParams)) *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOutageSimulationApiParams)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call) Return(_a0 admin.GetOutageSimulationApiRequest) *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOutageSimulationApiParams) admin.GetOutageSimulationApiRequest) *ClusterOutageSimulationApi_GetOutageSimulationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// StartOutageSimulation provides a mock function with given fields: ctx, groupId, clusterName, clusterOutageSimulation +func (_m *ClusterOutageSimulationApi) StartOutageSimulation(ctx context.Context, groupId string, clusterName string, clusterOutageSimulation *admin.ClusterOutageSimulation) admin.StartOutageSimulationApiRequest { + ret := _m.Called(ctx, groupId, clusterName, clusterOutageSimulation) + + if len(ret) == 0 { + panic("no return value specified for StartOutageSimulation") + } + + var r0 admin.StartOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ClusterOutageSimulation) admin.StartOutageSimulationApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, clusterOutageSimulation) + } else { + r0 = ret.Get(0).(admin.StartOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_StartOutageSimulation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartOutageSimulation' +type ClusterOutageSimulationApi_StartOutageSimulation_Call struct { + *mock.Call +} + +// StartOutageSimulation is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - clusterOutageSimulation *admin.ClusterOutageSimulation +func (_e *ClusterOutageSimulationApi_Expecter) StartOutageSimulation(ctx interface{}, groupId interface{}, clusterName interface{}, clusterOutageSimulation interface{}) *ClusterOutageSimulationApi_StartOutageSimulation_Call { + return &ClusterOutageSimulationApi_StartOutageSimulation_Call{Call: _e.mock.On("StartOutageSimulation", ctx, groupId, clusterName, clusterOutageSimulation)} +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulation_Call) Run(run func(ctx context.Context, groupId string, clusterName string, clusterOutageSimulation *admin.ClusterOutageSimulation)) *ClusterOutageSimulationApi_StartOutageSimulation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ClusterOutageSimulation)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulation_Call) Return(_a0 admin.StartOutageSimulationApiRequest) *ClusterOutageSimulationApi_StartOutageSimulation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulation_Call) RunAndReturn(run func(context.Context, string, string, *admin.ClusterOutageSimulation) admin.StartOutageSimulationApiRequest) *ClusterOutageSimulationApi_StartOutageSimulation_Call { + _c.Call.Return(run) + return _c +} + +// StartOutageSimulationExecute provides a mock function with given fields: r +func (_m *ClusterOutageSimulationApi) StartOutageSimulationExecute(r admin.StartOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for StartOutageSimulationExecute") + } + + var r0 *admin.ClusterOutageSimulation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.StartOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.StartOutageSimulationApiRequest) *admin.ClusterOutageSimulation); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ClusterOutageSimulation) + } + } + + if rf, ok := ret.Get(1).(func(admin.StartOutageSimulationApiRequest) *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.StartOutageSimulationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ClusterOutageSimulationApi_StartOutageSimulationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartOutageSimulationExecute' +type ClusterOutageSimulationApi_StartOutageSimulationExecute_Call struct { + *mock.Call +} + +// StartOutageSimulationExecute is a helper method to define mock.On call +// - r admin.StartOutageSimulationApiRequest +func (_e *ClusterOutageSimulationApi_Expecter) StartOutageSimulationExecute(r interface{}) *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call { + return &ClusterOutageSimulationApi_StartOutageSimulationExecute_Call{Call: _e.mock.On("StartOutageSimulationExecute", r)} +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call) Run(run func(r admin.StartOutageSimulationApiRequest)) *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.StartOutageSimulationApiRequest)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call) Return(_a0 *admin.ClusterOutageSimulation, _a1 *http.Response, _a2 error) *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call) RunAndReturn(run func(admin.StartOutageSimulationApiRequest) (*admin.ClusterOutageSimulation, *http.Response, error)) *ClusterOutageSimulationApi_StartOutageSimulationExecute_Call { + _c.Call.Return(run) + return _c +} + +// StartOutageSimulationWithParams provides a mock function with given fields: ctx, args +func (_m *ClusterOutageSimulationApi) StartOutageSimulationWithParams(ctx context.Context, args *admin.StartOutageSimulationApiParams) admin.StartOutageSimulationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for StartOutageSimulationWithParams") + } + + var r0 admin.StartOutageSimulationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.StartOutageSimulationApiParams) admin.StartOutageSimulationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.StartOutageSimulationApiRequest) + } + + return r0 +} + +// ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartOutageSimulationWithParams' +type ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call struct { + *mock.Call +} + +// StartOutageSimulationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.StartOutageSimulationApiParams +func (_e *ClusterOutageSimulationApi_Expecter) StartOutageSimulationWithParams(ctx interface{}, args interface{}) *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call { + return &ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call{Call: _e.mock.On("StartOutageSimulationWithParams", ctx, args)} +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call) Run(run func(ctx context.Context, args *admin.StartOutageSimulationApiParams)) *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.StartOutageSimulationApiParams)) + }) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call) Return(_a0 admin.StartOutageSimulationApiRequest) *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call) RunAndReturn(run func(context.Context, *admin.StartOutageSimulationApiParams) admin.StartOutageSimulationApiRequest) *ClusterOutageSimulationApi_StartOutageSimulationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewClusterOutageSimulationApi creates a new instance of ClusterOutageSimulationApi. 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 NewClusterOutageSimulationApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ClusterOutageSimulationApi { + mock := &ClusterOutageSimulationApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/clusters_api.go b/mockadmin/clusters_api.go new file mode 100644 index 000000000..a35ee9fa8 --- /dev/null +++ b/mockadmin/clusters_api.go @@ -0,0 +1,2450 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +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/mockadmin/custom_database_roles_api.go b/mockadmin/custom_database_roles_api.go new file mode 100644 index 000000000..4e280c238 --- /dev/null +++ b/mockadmin/custom_database_roles_api.go @@ -0,0 +1,841 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// CustomDatabaseRolesApi is an autogenerated mock type for the CustomDatabaseRolesApi type +type CustomDatabaseRolesApi struct { + mock.Mock +} + +type CustomDatabaseRolesApi_Expecter struct { + mock *mock.Mock +} + +func (_m *CustomDatabaseRolesApi) EXPECT() *CustomDatabaseRolesApi_Expecter { + return &CustomDatabaseRolesApi_Expecter{mock: &_m.Mock} +} + +// CreateCustomDatabaseRole provides a mock function with given fields: ctx, groupId, userCustomDBRole +func (_m *CustomDatabaseRolesApi) CreateCustomDatabaseRole(ctx context.Context, groupId string, userCustomDBRole *admin.UserCustomDBRole) admin.CreateCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, groupId, userCustomDBRole) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomDatabaseRole") + } + + var r0 admin.CreateCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.UserCustomDBRole) admin.CreateCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, groupId, userCustomDBRole) + } else { + r0 = ret.Get(0).(admin.CreateCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomDatabaseRole' +type CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call struct { + *mock.Call +} + +// CreateCustomDatabaseRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - userCustomDBRole *admin.UserCustomDBRole +func (_e *CustomDatabaseRolesApi_Expecter) CreateCustomDatabaseRole(ctx interface{}, groupId interface{}, userCustomDBRole interface{}) *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call { + return &CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call{Call: _e.mock.On("CreateCustomDatabaseRole", ctx, groupId, userCustomDBRole)} +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call) Run(run func(ctx context.Context, groupId string, userCustomDBRole *admin.UserCustomDBRole)) *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.UserCustomDBRole)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call) Return(_a0 admin.CreateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call) RunAndReturn(run func(context.Context, string, *admin.UserCustomDBRole) admin.CreateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_CreateCustomDatabaseRole_Call { + _c.Call.Return(run) + return _c +} + +// CreateCustomDatabaseRoleExecute provides a mock function with given fields: r +func (_m *CustomDatabaseRolesApi) CreateCustomDatabaseRoleExecute(r admin.CreateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomDatabaseRoleExecute") + } + + var r0 *admin.UserCustomDBRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateCustomDatabaseRoleApiRequest) *admin.UserCustomDBRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserCustomDBRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateCustomDatabaseRoleApiRequest) *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.CreateCustomDatabaseRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomDatabaseRoleExecute' +type CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call struct { + *mock.Call +} + +// CreateCustomDatabaseRoleExecute is a helper method to define mock.On call +// - r admin.CreateCustomDatabaseRoleApiRequest +func (_e *CustomDatabaseRolesApi_Expecter) CreateCustomDatabaseRoleExecute(r interface{}) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call { + return &CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call{Call: _e.mock.On("CreateCustomDatabaseRoleExecute", r)} +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call) Run(run func(r admin.CreateCustomDatabaseRoleApiRequest)) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateCustomDatabaseRoleApiRequest)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call) Return(_a0 *admin.UserCustomDBRole, _a1 *http.Response, _a2 error) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call) RunAndReturn(run func(admin.CreateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateCustomDatabaseRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CustomDatabaseRolesApi) CreateCustomDatabaseRoleWithParams(ctx context.Context, args *admin.CreateCustomDatabaseRoleApiParams) admin.CreateCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomDatabaseRoleWithParams") + } + + var r0 admin.CreateCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateCustomDatabaseRoleApiParams) admin.CreateCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomDatabaseRoleWithParams' +type CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call struct { + *mock.Call +} + +// CreateCustomDatabaseRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateCustomDatabaseRoleApiParams +func (_e *CustomDatabaseRolesApi_Expecter) CreateCustomDatabaseRoleWithParams(ctx interface{}, args interface{}) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call { + return &CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call{Call: _e.mock.On("CreateCustomDatabaseRoleWithParams", ctx, args)} +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateCustomDatabaseRoleApiParams)) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateCustomDatabaseRoleApiParams)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call) Return(_a0 admin.CreateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateCustomDatabaseRoleApiParams) admin.CreateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_CreateCustomDatabaseRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCustomDatabaseRole provides a mock function with given fields: ctx, groupId, roleName +func (_m *CustomDatabaseRolesApi) DeleteCustomDatabaseRole(ctx context.Context, groupId string, roleName string) admin.DeleteCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, groupId, roleName) + + if len(ret) == 0 { + panic("no return value specified for DeleteCustomDatabaseRole") + } + + var r0 admin.DeleteCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, groupId, roleName) + } else { + r0 = ret.Get(0).(admin.DeleteCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCustomDatabaseRole' +type CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call struct { + *mock.Call +} + +// DeleteCustomDatabaseRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - roleName string +func (_e *CustomDatabaseRolesApi_Expecter) DeleteCustomDatabaseRole(ctx interface{}, groupId interface{}, roleName interface{}) *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call { + return &CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call{Call: _e.mock.On("DeleteCustomDatabaseRole", ctx, groupId, roleName)} +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call) Run(run func(ctx context.Context, groupId string, roleName string)) *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call) Return(_a0 admin.DeleteCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_DeleteCustomDatabaseRole_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCustomDatabaseRoleExecute provides a mock function with given fields: r +func (_m *CustomDatabaseRolesApi) DeleteCustomDatabaseRoleExecute(r admin.DeleteCustomDatabaseRoleApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteCustomDatabaseRoleExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeleteCustomDatabaseRoleApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteCustomDatabaseRoleApiRequest) *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.DeleteCustomDatabaseRoleApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCustomDatabaseRoleExecute' +type CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call struct { + *mock.Call +} + +// DeleteCustomDatabaseRoleExecute is a helper method to define mock.On call +// - r admin.DeleteCustomDatabaseRoleApiRequest +func (_e *CustomDatabaseRolesApi_Expecter) DeleteCustomDatabaseRoleExecute(r interface{}) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call { + return &CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call{Call: _e.mock.On("DeleteCustomDatabaseRoleExecute", r)} +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call) Run(run func(r admin.DeleteCustomDatabaseRoleApiRequest)) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteCustomDatabaseRoleApiRequest)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call) Return(_a0 *http.Response, _a1 error) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call) RunAndReturn(run func(admin.DeleteCustomDatabaseRoleApiRequest) (*http.Response, error)) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCustomDatabaseRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CustomDatabaseRolesApi) DeleteCustomDatabaseRoleWithParams(ctx context.Context, args *admin.DeleteCustomDatabaseRoleApiParams) admin.DeleteCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteCustomDatabaseRoleWithParams") + } + + var r0 admin.DeleteCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteCustomDatabaseRoleApiParams) admin.DeleteCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCustomDatabaseRoleWithParams' +type CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call struct { + *mock.Call +} + +// DeleteCustomDatabaseRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteCustomDatabaseRoleApiParams +func (_e *CustomDatabaseRolesApi_Expecter) DeleteCustomDatabaseRoleWithParams(ctx interface{}, args interface{}) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call { + return &CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call{Call: _e.mock.On("DeleteCustomDatabaseRoleWithParams", ctx, args)} +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteCustomDatabaseRoleApiParams)) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteCustomDatabaseRoleApiParams)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call) Return(_a0 admin.DeleteCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteCustomDatabaseRoleApiParams) admin.DeleteCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_DeleteCustomDatabaseRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetCustomDatabaseRole provides a mock function with given fields: ctx, groupId, roleName +func (_m *CustomDatabaseRolesApi) GetCustomDatabaseRole(ctx context.Context, groupId string, roleName string) admin.GetCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, groupId, roleName) + + if len(ret) == 0 { + panic("no return value specified for GetCustomDatabaseRole") + } + + var r0 admin.GetCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, groupId, roleName) + } else { + r0 = ret.Get(0).(admin.GetCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_GetCustomDatabaseRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomDatabaseRole' +type CustomDatabaseRolesApi_GetCustomDatabaseRole_Call struct { + *mock.Call +} + +// GetCustomDatabaseRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - roleName string +func (_e *CustomDatabaseRolesApi_Expecter) GetCustomDatabaseRole(ctx interface{}, groupId interface{}, roleName interface{}) *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call { + return &CustomDatabaseRolesApi_GetCustomDatabaseRole_Call{Call: _e.mock.On("GetCustomDatabaseRole", ctx, groupId, roleName)} +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call) Run(run func(ctx context.Context, groupId string, roleName string)) *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call) Return(_a0 admin.GetCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call) RunAndReturn(run func(context.Context, string, string) admin.GetCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_GetCustomDatabaseRole_Call { + _c.Call.Return(run) + return _c +} + +// GetCustomDatabaseRoleExecute provides a mock function with given fields: r +func (_m *CustomDatabaseRolesApi) GetCustomDatabaseRoleExecute(r admin.GetCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetCustomDatabaseRoleExecute") + } + + var r0 *admin.UserCustomDBRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetCustomDatabaseRoleApiRequest) *admin.UserCustomDBRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserCustomDBRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetCustomDatabaseRoleApiRequest) *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.GetCustomDatabaseRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomDatabaseRoleExecute' +type CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call struct { + *mock.Call +} + +// GetCustomDatabaseRoleExecute is a helper method to define mock.On call +// - r admin.GetCustomDatabaseRoleApiRequest +func (_e *CustomDatabaseRolesApi_Expecter) GetCustomDatabaseRoleExecute(r interface{}) *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call { + return &CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call{Call: _e.mock.On("GetCustomDatabaseRoleExecute", r)} +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call) Run(run func(r admin.GetCustomDatabaseRoleApiRequest)) *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetCustomDatabaseRoleApiRequest)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call) Return(_a0 *admin.UserCustomDBRole, _a1 *http.Response, _a2 error) *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call) RunAndReturn(run func(admin.GetCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)) *CustomDatabaseRolesApi_GetCustomDatabaseRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetCustomDatabaseRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CustomDatabaseRolesApi) GetCustomDatabaseRoleWithParams(ctx context.Context, args *admin.GetCustomDatabaseRoleApiParams) admin.GetCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetCustomDatabaseRoleWithParams") + } + + var r0 admin.GetCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetCustomDatabaseRoleApiParams) admin.GetCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomDatabaseRoleWithParams' +type CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call struct { + *mock.Call +} + +// GetCustomDatabaseRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetCustomDatabaseRoleApiParams +func (_e *CustomDatabaseRolesApi_Expecter) GetCustomDatabaseRoleWithParams(ctx interface{}, args interface{}) *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call { + return &CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call{Call: _e.mock.On("GetCustomDatabaseRoleWithParams", ctx, args)} +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.GetCustomDatabaseRoleApiParams)) *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetCustomDatabaseRoleApiParams)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call) Return(_a0 admin.GetCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetCustomDatabaseRoleApiParams) admin.GetCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_GetCustomDatabaseRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListCustomDatabaseRoles provides a mock function with given fields: ctx, groupId +func (_m *CustomDatabaseRolesApi) ListCustomDatabaseRoles(ctx context.Context, groupId string) admin.ListCustomDatabaseRolesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListCustomDatabaseRoles") + } + + var r0 admin.ListCustomDatabaseRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListCustomDatabaseRolesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListCustomDatabaseRolesApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCustomDatabaseRoles' +type CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call struct { + *mock.Call +} + +// ListCustomDatabaseRoles is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *CustomDatabaseRolesApi_Expecter) ListCustomDatabaseRoles(ctx interface{}, groupId interface{}) *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call { + return &CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call{Call: _e.mock.On("ListCustomDatabaseRoles", ctx, groupId)} +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call) Run(run func(ctx context.Context, groupId string)) *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call) Return(_a0 admin.ListCustomDatabaseRolesApiRequest) *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call) RunAndReturn(run func(context.Context, string) admin.ListCustomDatabaseRolesApiRequest) *CustomDatabaseRolesApi_ListCustomDatabaseRoles_Call { + _c.Call.Return(run) + return _c +} + +// ListCustomDatabaseRolesExecute provides a mock function with given fields: r +func (_m *CustomDatabaseRolesApi) ListCustomDatabaseRolesExecute(r admin.ListCustomDatabaseRolesApiRequest) ([]admin.UserCustomDBRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListCustomDatabaseRolesExecute") + } + + var r0 []admin.UserCustomDBRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListCustomDatabaseRolesApiRequest) ([]admin.UserCustomDBRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListCustomDatabaseRolesApiRequest) []admin.UserCustomDBRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.UserCustomDBRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListCustomDatabaseRolesApiRequest) *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.ListCustomDatabaseRolesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCustomDatabaseRolesExecute' +type CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call struct { + *mock.Call +} + +// ListCustomDatabaseRolesExecute is a helper method to define mock.On call +// - r admin.ListCustomDatabaseRolesApiRequest +func (_e *CustomDatabaseRolesApi_Expecter) ListCustomDatabaseRolesExecute(r interface{}) *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call { + return &CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call{Call: _e.mock.On("ListCustomDatabaseRolesExecute", r)} +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call) Run(run func(r admin.ListCustomDatabaseRolesApiRequest)) *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListCustomDatabaseRolesApiRequest)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call) Return(_a0 []admin.UserCustomDBRole, _a1 *http.Response, _a2 error) *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call) RunAndReturn(run func(admin.ListCustomDatabaseRolesApiRequest) ([]admin.UserCustomDBRole, *http.Response, error)) *CustomDatabaseRolesApi_ListCustomDatabaseRolesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListCustomDatabaseRolesWithParams provides a mock function with given fields: ctx, args +func (_m *CustomDatabaseRolesApi) ListCustomDatabaseRolesWithParams(ctx context.Context, args *admin.ListCustomDatabaseRolesApiParams) admin.ListCustomDatabaseRolesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListCustomDatabaseRolesWithParams") + } + + var r0 admin.ListCustomDatabaseRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListCustomDatabaseRolesApiParams) admin.ListCustomDatabaseRolesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListCustomDatabaseRolesApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCustomDatabaseRolesWithParams' +type CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call struct { + *mock.Call +} + +// ListCustomDatabaseRolesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListCustomDatabaseRolesApiParams +func (_e *CustomDatabaseRolesApi_Expecter) ListCustomDatabaseRolesWithParams(ctx interface{}, args interface{}) *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call { + return &CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call{Call: _e.mock.On("ListCustomDatabaseRolesWithParams", ctx, args)} +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListCustomDatabaseRolesApiParams)) *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListCustomDatabaseRolesApiParams)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call) Return(_a0 admin.ListCustomDatabaseRolesApiRequest) *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListCustomDatabaseRolesApiParams) admin.ListCustomDatabaseRolesApiRequest) *CustomDatabaseRolesApi_ListCustomDatabaseRolesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateCustomDatabaseRole provides a mock function with given fields: ctx, groupId, roleName, updateCustomDBRole +func (_m *CustomDatabaseRolesApi) UpdateCustomDatabaseRole(ctx context.Context, groupId string, roleName string, updateCustomDBRole *admin.UpdateCustomDBRole) admin.UpdateCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, groupId, roleName, updateCustomDBRole) + + if len(ret) == 0 { + panic("no return value specified for UpdateCustomDatabaseRole") + } + + var r0 admin.UpdateCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UpdateCustomDBRole) admin.UpdateCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, groupId, roleName, updateCustomDBRole) + } else { + r0 = ret.Get(0).(admin.UpdateCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCustomDatabaseRole' +type CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call struct { + *mock.Call +} + +// UpdateCustomDatabaseRole is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - roleName string +// - updateCustomDBRole *admin.UpdateCustomDBRole +func (_e *CustomDatabaseRolesApi_Expecter) UpdateCustomDatabaseRole(ctx interface{}, groupId interface{}, roleName interface{}, updateCustomDBRole interface{}) *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call { + return &CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call{Call: _e.mock.On("UpdateCustomDatabaseRole", ctx, groupId, roleName, updateCustomDBRole)} +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call) Run(run func(ctx context.Context, groupId string, roleName string, updateCustomDBRole *admin.UpdateCustomDBRole)) *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateCustomDBRole)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call) Return(_a0 admin.UpdateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateCustomDBRole) admin.UpdateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_UpdateCustomDatabaseRole_Call { + _c.Call.Return(run) + return _c +} + +// UpdateCustomDatabaseRoleExecute provides a mock function with given fields: r +func (_m *CustomDatabaseRolesApi) UpdateCustomDatabaseRoleExecute(r admin.UpdateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateCustomDatabaseRoleExecute") + } + + var r0 *admin.UserCustomDBRole + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateCustomDatabaseRoleApiRequest) *admin.UserCustomDBRole); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserCustomDBRole) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateCustomDatabaseRoleApiRequest) *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.UpdateCustomDatabaseRoleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCustomDatabaseRoleExecute' +type CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call struct { + *mock.Call +} + +// UpdateCustomDatabaseRoleExecute is a helper method to define mock.On call +// - r admin.UpdateCustomDatabaseRoleApiRequest +func (_e *CustomDatabaseRolesApi_Expecter) UpdateCustomDatabaseRoleExecute(r interface{}) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call { + return &CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call{Call: _e.mock.On("UpdateCustomDatabaseRoleExecute", r)} +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call) Run(run func(r admin.UpdateCustomDatabaseRoleApiRequest)) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateCustomDatabaseRoleApiRequest)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call) Return(_a0 *admin.UserCustomDBRole, _a1 *http.Response, _a2 error) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call) RunAndReturn(run func(admin.UpdateCustomDatabaseRoleApiRequest) (*admin.UserCustomDBRole, *http.Response, error)) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateCustomDatabaseRoleWithParams provides a mock function with given fields: ctx, args +func (_m *CustomDatabaseRolesApi) UpdateCustomDatabaseRoleWithParams(ctx context.Context, args *admin.UpdateCustomDatabaseRoleApiParams) admin.UpdateCustomDatabaseRoleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateCustomDatabaseRoleWithParams") + } + + var r0 admin.UpdateCustomDatabaseRoleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateCustomDatabaseRoleApiParams) admin.UpdateCustomDatabaseRoleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateCustomDatabaseRoleApiRequest) + } + + return r0 +} + +// CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCustomDatabaseRoleWithParams' +type CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call struct { + *mock.Call +} + +// UpdateCustomDatabaseRoleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateCustomDatabaseRoleApiParams +func (_e *CustomDatabaseRolesApi_Expecter) UpdateCustomDatabaseRoleWithParams(ctx interface{}, args interface{}) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call { + return &CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call{Call: _e.mock.On("UpdateCustomDatabaseRoleWithParams", ctx, args)} +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateCustomDatabaseRoleApiParams)) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateCustomDatabaseRoleApiParams)) + }) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call) Return(_a0 admin.UpdateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateCustomDatabaseRoleApiParams) admin.UpdateCustomDatabaseRoleApiRequest) *CustomDatabaseRolesApi_UpdateCustomDatabaseRoleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewCustomDatabaseRolesApi creates a new instance of CustomDatabaseRolesApi. 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 NewCustomDatabaseRolesApi(t interface { + mock.TestingT + Cleanup(func()) +}) *CustomDatabaseRolesApi { + mock := &CustomDatabaseRolesApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/data_federation_api.go b/mockadmin/data_federation_api.go new file mode 100644 index 000000000..421fc0dca --- /dev/null +++ b/mockadmin/data_federation_api.go @@ -0,0 +1,2313 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + io "io" + + mock "github.com/stretchr/testify/mock" +) + +// DataFederationApi is an autogenerated mock type for the DataFederationApi type +type DataFederationApi struct { + mock.Mock +} + +type DataFederationApi_Expecter struct { + mock *mock.Mock +} + +func (_m *DataFederationApi) EXPECT() *DataFederationApi_Expecter { + return &DataFederationApi_Expecter{mock: &_m.Mock} +} + +// CreateDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, privateNetworkEndpointIdEntry +func (_m *DataFederationApi) CreateDataFederationPrivateEndpoint(ctx context.Context, groupId string, privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, privateNetworkEndpointIdEntry) + + if len(ret) == 0 { + panic("no return value specified for CreateDataFederationPrivateEndpoint") + } + + var r0 admin.CreateDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, privateNetworkEndpointIdEntry) + } else { + r0 = ret.Get(0).(admin.CreateDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateDataFederationPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDataFederationPrivateEndpoint' +type DataFederationApi_CreateDataFederationPrivateEndpoint_Call struct { + *mock.Call +} + +// CreateDataFederationPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry +func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, privateNetworkEndpointIdEntry interface{}) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call { + return &DataFederationApi_CreateDataFederationPrivateEndpoint_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpoint", ctx, groupId, privateNetworkEndpointIdEntry)} +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry)) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.PrivateNetworkEndpointIdEntry)) + }) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) Return(_a0 admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// CreateDataFederationPrivateEndpointExecute provides a mock function with given fields: r +func (_m *DataFederationApi) CreateDataFederationPrivateEndpointExecute(r admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateDataFederationPrivateEndpointExecute") + } + + var r0 *admin.PaginatedPrivateNetworkEndpointIdEntry + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateDataFederationPrivateEndpointApiRequest) *admin.PaginatedPrivateNetworkEndpointIdEntry); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedPrivateNetworkEndpointIdEntry) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateDataFederationPrivateEndpointApiRequest) *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.CreateDataFederationPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDataFederationPrivateEndpointExecute' +type DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call struct { + *mock.Call +} + +// CreateDataFederationPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.CreateDataFederationPrivateEndpointApiRequest +func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call { + return &DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpointExecute", r)} +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.CreateDataFederationPrivateEndpointApiRequest)) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateDataFederationPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) Return(_a0 *admin.PaginatedPrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) CreateDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateDataFederationPrivateEndpointWithParams") + } + + var r0 admin.CreateDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDataFederationPrivateEndpointWithParams' +type DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// CreateDataFederationPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateDataFederationPrivateEndpointApiParams +func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call { + return &DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpointWithParams", ctx, args)} +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateDataFederationPrivateEndpointApiParams)) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateDataFederationPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateFederatedDatabase provides a mock function with given fields: ctx, groupId, dataLakeTenant +func (_m *DataFederationApi) CreateFederatedDatabase(ctx context.Context, groupId string, dataLakeTenant *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest { + ret := _m.Called(ctx, groupId, dataLakeTenant) + + if len(ret) == 0 { + panic("no return value specified for CreateFederatedDatabase") + } + + var r0 admin.CreateFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, groupId, dataLakeTenant) + } else { + r0 = ret.Get(0).(admin.CreateFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateFederatedDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFederatedDatabase' +type DataFederationApi_CreateFederatedDatabase_Call struct { + *mock.Call +} + +// CreateFederatedDatabase is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - dataLakeTenant *admin.DataLakeTenant +func (_e *DataFederationApi_Expecter) CreateFederatedDatabase(ctx interface{}, groupId interface{}, dataLakeTenant interface{}) *DataFederationApi_CreateFederatedDatabase_Call { + return &DataFederationApi_CreateFederatedDatabase_Call{Call: _e.mock.On("CreateFederatedDatabase", ctx, groupId, dataLakeTenant)} +} + +func (_c *DataFederationApi_CreateFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, dataLakeTenant *admin.DataLakeTenant)) *DataFederationApi_CreateFederatedDatabase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.DataLakeTenant)) + }) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabase_Call) Return(_a0 admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabase_Call { + _c.Call.Return(run) + return _c +} + +// CreateFederatedDatabaseExecute provides a mock function with given fields: r +func (_m *DataFederationApi) CreateFederatedDatabaseExecute(r admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateFederatedDatabaseExecute") + } + + var r0 *admin.DataLakeTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateFederatedDatabaseApiRequest) *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.CreateFederatedDatabaseApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_CreateFederatedDatabaseExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFederatedDatabaseExecute' +type DataFederationApi_CreateFederatedDatabaseExecute_Call struct { + *mock.Call +} + +// CreateFederatedDatabaseExecute is a helper method to define mock.On call +// - r admin.CreateFederatedDatabaseApiRequest +func (_e *DataFederationApi_Expecter) CreateFederatedDatabaseExecute(r interface{}) *DataFederationApi_CreateFederatedDatabaseExecute_Call { + return &DataFederationApi_CreateFederatedDatabaseExecute_Call{Call: _e.mock.On("CreateFederatedDatabaseExecute", r)} +} + +func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) Run(run func(r admin.CreateFederatedDatabaseApiRequest)) *DataFederationApi_CreateFederatedDatabaseExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateFederatedDatabaseApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_CreateFederatedDatabaseExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_CreateFederatedDatabaseExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateFederatedDatabaseWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) CreateFederatedDatabaseWithParams(ctx context.Context, args *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateFederatedDatabaseWithParams") + } + + var r0 admin.CreateFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateFederatedDatabaseWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFederatedDatabaseWithParams' +type DataFederationApi_CreateFederatedDatabaseWithParams_Call struct { + *mock.Call +} + +// CreateFederatedDatabaseWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateFederatedDatabaseApiParams +func (_e *DataFederationApi_Expecter) CreateFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateFederatedDatabaseWithParams_Call { + return &DataFederationApi_CreateFederatedDatabaseWithParams_Call{Call: _e.mock.On("CreateFederatedDatabaseWithParams", ctx, args)} +} + +func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateFederatedDatabaseApiParams)) *DataFederationApi_CreateFederatedDatabaseWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateFederatedDatabaseApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) Return(_a0 admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabaseWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabaseWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateOneDataFederationQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit +func (_m *DataFederationApi) CreateOneDataFederationQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string, dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest { + ret := _m.Called(ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit) + + if len(ret) == 0 { + panic("no return value specified for CreateOneDataFederationQueryLimit") + } + + var r0 admin.CreateOneDataFederationQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit) + } else { + r0 = ret.Get(0).(admin.CreateOneDataFederationQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateOneDataFederationQueryLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOneDataFederationQueryLimit' +type DataFederationApi_CreateOneDataFederationQueryLimit_Call struct { + *mock.Call +} + +// CreateOneDataFederationQueryLimit is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - limitName string +// - dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit +func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}, dataFederationTenantQueryLimit interface{}) *DataFederationApi_CreateOneDataFederationQueryLimit_Call { + return &DataFederationApi_CreateOneDataFederationQueryLimit_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimit", ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit)} +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string, dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit)) *DataFederationApi_CreateOneDataFederationQueryLimit_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.DataFederationTenantQueryLimit)) + }) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) Return(_a0 admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimit_Call { + _c.Call.Return(run) + return _c +} + +// CreateOneDataFederationQueryLimitExecute provides a mock function with given fields: r +func (_m *DataFederationApi) CreateOneDataFederationQueryLimitExecute(r admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateOneDataFederationQueryLimitExecute") + } + + var r0 *admin.DataFederationTenantQueryLimit + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateOneDataFederationQueryLimitApiRequest) *admin.DataFederationTenantQueryLimit); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataFederationTenantQueryLimit) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateOneDataFederationQueryLimitApiRequest) *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.CreateOneDataFederationQueryLimitApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOneDataFederationQueryLimitExecute' +type DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call struct { + *mock.Call +} + +// CreateOneDataFederationQueryLimitExecute is a helper method to define mock.On call +// - r admin.CreateOneDataFederationQueryLimitApiRequest +func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimitExecute(r interface{}) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call { + return &DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimitExecute", r)} +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) Run(run func(r admin.CreateOneDataFederationQueryLimitApiRequest)) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateOneDataFederationQueryLimitApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) Return(_a0 *admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) RunAndReturn(run func(admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateOneDataFederationQueryLimitWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) CreateOneDataFederationQueryLimitWithParams(ctx context.Context, args *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateOneDataFederationQueryLimitWithParams") + } + + var r0 admin.CreateOneDataFederationQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateOneDataFederationQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOneDataFederationQueryLimitWithParams' +type DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call struct { + *mock.Call +} + +// CreateOneDataFederationQueryLimitWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateOneDataFederationQueryLimitApiParams +func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call { + return &DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimitWithParams", ctx, args)} +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateOneDataFederationQueryLimitApiParams)) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateOneDataFederationQueryLimitApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) Return(_a0 admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, endpointId +func (_m *DataFederationApi) DeleteDataFederationPrivateEndpoint(ctx context.Context, groupId string, endpointId string) admin.DeleteDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, endpointId) + + if len(ret) == 0 { + panic("no return value specified for DeleteDataFederationPrivateEndpoint") + } + + var r0 admin.DeleteDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, endpointId) + } else { + r0 = ret.Get(0).(admin.DeleteDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteDataFederationPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDataFederationPrivateEndpoint' +type DataFederationApi_DeleteDataFederationPrivateEndpoint_Call struct { + *mock.Call +} + +// DeleteDataFederationPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - endpointId string +func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, endpointId interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call { + return &DataFederationApi_DeleteDataFederationPrivateEndpoint_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpoint", ctx, groupId, endpointId)} +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, endpointId string)) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call) Return(_a0 admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDataFederationPrivateEndpointExecute provides a mock function with given fields: r +func (_m *DataFederationApi) DeleteDataFederationPrivateEndpointExecute(r admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteDataFederationPrivateEndpointExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) 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.DeleteDataFederationPrivateEndpointApiRequest) *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.DeleteDataFederationPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDataFederationPrivateEndpointExecute' +type DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call struct { + *mock.Call +} + +// DeleteDataFederationPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.DeleteDataFederationPrivateEndpointApiRequest +func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call { + return &DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpointExecute", r)} +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.DeleteDataFederationPrivateEndpointApiRequest)) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteDataFederationPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) DeleteDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteDataFederationPrivateEndpointWithParams") + } + + var r0 admin.DeleteDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDataFederationPrivateEndpointWithParams' +type DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// DeleteDataFederationPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteDataFederationPrivateEndpointApiParams +func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call { + return &DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpointWithParams", ctx, args)} +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteDataFederationPrivateEndpointApiParams)) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteDataFederationPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName +func (_m *DataFederationApi) DeleteFederatedDatabase(ctx context.Context, groupId string, tenantName string) admin.DeleteFederatedDatabaseApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederatedDatabase") + } + + var r0 admin.DeleteFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.DeleteFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteFederatedDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederatedDatabase' +type DataFederationApi_DeleteFederatedDatabase_Call struct { + *mock.Call +} + +// DeleteFederatedDatabase is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *DataFederationApi_Expecter) DeleteFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_DeleteFederatedDatabase_Call { + return &DataFederationApi_DeleteFederatedDatabase_Call{Call: _e.mock.On("DeleteFederatedDatabase", ctx, groupId, tenantName)} +} + +func (_c *DataFederationApi_DeleteFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *DataFederationApi_DeleteFederatedDatabase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabase_Call) Return(_a0 admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabase_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederatedDatabaseExecute provides a mock function with given fields: r +func (_m *DataFederationApi) DeleteFederatedDatabaseExecute(r admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederatedDatabaseExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteFederatedDatabaseApiRequest) 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.DeleteFederatedDatabaseApiRequest) *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.DeleteFederatedDatabaseApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_DeleteFederatedDatabaseExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederatedDatabaseExecute' +type DataFederationApi_DeleteFederatedDatabaseExecute_Call struct { + *mock.Call +} + +// DeleteFederatedDatabaseExecute is a helper method to define mock.On call +// - r admin.DeleteFederatedDatabaseApiRequest +func (_e *DataFederationApi_Expecter) DeleteFederatedDatabaseExecute(r interface{}) *DataFederationApi_DeleteFederatedDatabaseExecute_Call { + return &DataFederationApi_DeleteFederatedDatabaseExecute_Call{Call: _e.mock.On("DeleteFederatedDatabaseExecute", r)} +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) Run(run func(r admin.DeleteFederatedDatabaseApiRequest)) *DataFederationApi_DeleteFederatedDatabaseExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteFederatedDatabaseApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteFederatedDatabaseExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteFederatedDatabaseExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederatedDatabaseWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) DeleteFederatedDatabaseWithParams(ctx context.Context, args *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederatedDatabaseWithParams") + } + + var r0 admin.DeleteFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteFederatedDatabaseWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederatedDatabaseWithParams' +type DataFederationApi_DeleteFederatedDatabaseWithParams_Call struct { + *mock.Call +} + +// DeleteFederatedDatabaseWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteFederatedDatabaseApiParams +func (_e *DataFederationApi_Expecter) DeleteFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call { + return &DataFederationApi_DeleteFederatedDatabaseWithParams_Call{Call: _e.mock.On("DeleteFederatedDatabaseWithParams", ctx, args)} +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteFederatedDatabaseApiParams)) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteFederatedDatabaseApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) Return(_a0 admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOneDataFederationInstanceQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName +func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest { + ret := _m.Called(ctx, groupId, tenantName, limitName) + + if len(ret) == 0 { + panic("no return value specified for DeleteOneDataFederationInstanceQueryLimit") + } + + var r0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, limitName) + } else { + r0 = ret.Get(0).(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOneDataFederationInstanceQueryLimit' +type DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call struct { + *mock.Call +} + +// DeleteOneDataFederationInstanceQueryLimit is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - limitName string +func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call { + return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimit", ctx, groupId, tenantName, limitName)} +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_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 *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) Return(_a0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOneDataFederationInstanceQueryLimitExecute provides a mock function with given fields: r +func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimitExecute(r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteOneDataFederationInstanceQueryLimitExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) 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.DeleteOneDataFederationInstanceQueryLimitApiRequest) *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.DeleteOneDataFederationInstanceQueryLimitApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOneDataFederationInstanceQueryLimitExecute' +type DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call struct { + *mock.Call +} + +// DeleteOneDataFederationInstanceQueryLimitExecute is a helper method to define mock.On call +// - r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest +func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimitExecute(r interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call { + return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimitExecute", r)} +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) Run(run func(r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) RunAndReturn(run func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOneDataFederationInstanceQueryLimitWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimitWithParams(ctx context.Context, args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteOneDataFederationInstanceQueryLimitWithParams") + } + + var r0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOneDataFederationInstanceQueryLimitWithParams' +type DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call struct { + *mock.Call +} + +// DeleteOneDataFederationInstanceQueryLimitWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams +func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call { + return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimitWithParams", ctx, args)} +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteOneDataFederationInstanceQueryLimitApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) Return(_a0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DownloadFederatedDatabaseQueryLogs provides a mock function with given fields: ctx, groupId, tenantName +func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogs(ctx context.Context, groupId string, tenantName string) admin.DownloadFederatedDatabaseQueryLogsApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for DownloadFederatedDatabaseQueryLogs") + } + + var r0 admin.DownloadFederatedDatabaseQueryLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DownloadFederatedDatabaseQueryLogsApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.DownloadFederatedDatabaseQueryLogsApiRequest) + } + + return r0 +} + +// DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadFederatedDatabaseQueryLogs' +type DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call struct { + *mock.Call +} + +// DownloadFederatedDatabaseQueryLogs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogs(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call { + return &DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogs", ctx, groupId, tenantName)} +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call) Return(_a0 admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call) RunAndReturn(run func(context.Context, string, string) admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call { + _c.Call.Return(run) + return _c +} + +// DownloadFederatedDatabaseQueryLogsExecute provides a mock function with given fields: r +func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogsExecute(r admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DownloadFederatedDatabaseQueryLogsExecute") + } + + var r0 io.ReadCloser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) io.ReadCloser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) *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.DownloadFederatedDatabaseQueryLogsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadFederatedDatabaseQueryLogsExecute' +type DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call struct { + *mock.Call +} + +// DownloadFederatedDatabaseQueryLogsExecute is a helper method to define mock.On call +// - r admin.DownloadFederatedDatabaseQueryLogsApiRequest +func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogsExecute(r interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call { + return &DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogsExecute", r)} +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) Run(run func(r admin.DownloadFederatedDatabaseQueryLogsApiRequest)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DownloadFederatedDatabaseQueryLogsApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) RunAndReturn(run func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call { + _c.Call.Return(run) + return _c +} + +// DownloadFederatedDatabaseQueryLogsWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogsWithParams(ctx context.Context, args *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DownloadFederatedDatabaseQueryLogsWithParams") + } + + var r0 admin.DownloadFederatedDatabaseQueryLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DownloadFederatedDatabaseQueryLogsApiRequest) + } + + return r0 +} + +// DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadFederatedDatabaseQueryLogsWithParams' +type DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call struct { + *mock.Call +} + +// DownloadFederatedDatabaseQueryLogsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DownloadFederatedDatabaseQueryLogsApiParams +func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogsWithParams(ctx interface{}, args interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call { + return &DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogsWithParams", ctx, args)} +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadFederatedDatabaseQueryLogsApiParams)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DownloadFederatedDatabaseQueryLogsApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) Return(_a0 admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, endpointId +func (_m *DataFederationApi) GetDataFederationPrivateEndpoint(ctx context.Context, groupId string, endpointId string) admin.GetDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, endpointId) + + if len(ret) == 0 { + panic("no return value specified for GetDataFederationPrivateEndpoint") + } + + var r0 admin.GetDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, endpointId) + } else { + r0 = ret.Get(0).(admin.GetDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_GetDataFederationPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataFederationPrivateEndpoint' +type DataFederationApi_GetDataFederationPrivateEndpoint_Call struct { + *mock.Call +} + +// GetDataFederationPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - endpointId string +func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, endpointId interface{}) *DataFederationApi_GetDataFederationPrivateEndpoint_Call { + return &DataFederationApi_GetDataFederationPrivateEndpoint_Call{Call: _e.mock.On("GetDataFederationPrivateEndpoint", ctx, groupId, endpointId)} +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, endpointId string)) *DataFederationApi_GetDataFederationPrivateEndpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpoint_Call) Return(_a0 admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string) admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// GetDataFederationPrivateEndpointExecute provides a mock function with given fields: r +func (_m *DataFederationApi) GetDataFederationPrivateEndpointExecute(r admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDataFederationPrivateEndpointExecute") + } + + var r0 *admin.PrivateNetworkEndpointIdEntry + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDataFederationPrivateEndpointApiRequest) *admin.PrivateNetworkEndpointIdEntry); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PrivateNetworkEndpointIdEntry) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDataFederationPrivateEndpointApiRequest) *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.GetDataFederationPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_GetDataFederationPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataFederationPrivateEndpointExecute' +type DataFederationApi_GetDataFederationPrivateEndpointExecute_Call struct { + *mock.Call +} + +// GetDataFederationPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.GetDataFederationPrivateEndpointApiRequest +func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call { + return &DataFederationApi_GetDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("GetDataFederationPrivateEndpointExecute", r)} +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.GetDataFederationPrivateEndpointApiRequest)) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDataFederationPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) Return(_a0 *admin.PrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) GetDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDataFederationPrivateEndpointWithParams") + } + + var r0 admin.GetDataFederationPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDataFederationPrivateEndpointApiRequest) + } + + return r0 +} + +// DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataFederationPrivateEndpointWithParams' +type DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// GetDataFederationPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDataFederationPrivateEndpointApiParams +func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call { + return &DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("GetDataFederationPrivateEndpointWithParams", ctx, args)} +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDataFederationPrivateEndpointApiParams)) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDataFederationPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName +func (_m *DataFederationApi) GetFederatedDatabase(ctx context.Context, groupId string, tenantName string) admin.GetFederatedDatabaseApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for GetFederatedDatabase") + } + + var r0 admin.GetFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.GetFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_GetFederatedDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederatedDatabase' +type DataFederationApi_GetFederatedDatabase_Call struct { + *mock.Call +} + +// GetFederatedDatabase is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *DataFederationApi_Expecter) GetFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_GetFederatedDatabase_Call { + return &DataFederationApi_GetFederatedDatabase_Call{Call: _e.mock.On("GetFederatedDatabase", ctx, groupId, tenantName)} +} + +func (_c *DataFederationApi_GetFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *DataFederationApi_GetFederatedDatabase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabase_Call) Return(_a0 admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string) admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabase_Call { + _c.Call.Return(run) + return _c +} + +// GetFederatedDatabaseExecute provides a mock function with given fields: r +func (_m *DataFederationApi) GetFederatedDatabaseExecute(r admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetFederatedDatabaseExecute") + } + + var r0 *admin.DataLakeTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetFederatedDatabaseApiRequest) *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.GetFederatedDatabaseApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_GetFederatedDatabaseExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederatedDatabaseExecute' +type DataFederationApi_GetFederatedDatabaseExecute_Call struct { + *mock.Call +} + +// GetFederatedDatabaseExecute is a helper method to define mock.On call +// - r admin.GetFederatedDatabaseApiRequest +func (_e *DataFederationApi_Expecter) GetFederatedDatabaseExecute(r interface{}) *DataFederationApi_GetFederatedDatabaseExecute_Call { + return &DataFederationApi_GetFederatedDatabaseExecute_Call{Call: _e.mock.On("GetFederatedDatabaseExecute", r)} +} + +func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) Run(run func(r admin.GetFederatedDatabaseApiRequest)) *DataFederationApi_GetFederatedDatabaseExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetFederatedDatabaseApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_GetFederatedDatabaseExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_GetFederatedDatabaseExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetFederatedDatabaseWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) GetFederatedDatabaseWithParams(ctx context.Context, args *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetFederatedDatabaseWithParams") + } + + var r0 admin.GetFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_GetFederatedDatabaseWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederatedDatabaseWithParams' +type DataFederationApi_GetFederatedDatabaseWithParams_Call struct { + *mock.Call +} + +// GetFederatedDatabaseWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetFederatedDatabaseApiParams +func (_e *DataFederationApi_Expecter) GetFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_GetFederatedDatabaseWithParams_Call { + return &DataFederationApi_GetFederatedDatabaseWithParams_Call{Call: _e.mock.On("GetFederatedDatabaseWithParams", ctx, args)} +} + +func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.GetFederatedDatabaseApiParams)) *DataFederationApi_GetFederatedDatabaseWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetFederatedDatabaseApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) Return(_a0 admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabaseWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabaseWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDataFederationPrivateEndpoints provides a mock function with given fields: ctx, groupId +func (_m *DataFederationApi) ListDataFederationPrivateEndpoints(ctx context.Context, groupId string) admin.ListDataFederationPrivateEndpointsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListDataFederationPrivateEndpoints") + } + + var r0 admin.ListDataFederationPrivateEndpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListDataFederationPrivateEndpointsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListDataFederationPrivateEndpointsApiRequest) + } + + return r0 +} + +// DataFederationApi_ListDataFederationPrivateEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDataFederationPrivateEndpoints' +type DataFederationApi_ListDataFederationPrivateEndpoints_Call struct { + *mock.Call +} + +// ListDataFederationPrivateEndpoints is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpoints(ctx interface{}, groupId interface{}) *DataFederationApi_ListDataFederationPrivateEndpoints_Call { + return &DataFederationApi_ListDataFederationPrivateEndpoints_Call{Call: _e.mock.On("ListDataFederationPrivateEndpoints", ctx, groupId)} +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpoints_Call) Run(run func(ctx context.Context, groupId string)) *DataFederationApi_ListDataFederationPrivateEndpoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpoints_Call) Return(_a0 admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpoints_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpoints_Call) RunAndReturn(run func(context.Context, string) admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpoints_Call { + _c.Call.Return(run) + return _c +} + +// ListDataFederationPrivateEndpointsExecute provides a mock function with given fields: r +func (_m *DataFederationApi) ListDataFederationPrivateEndpointsExecute(r admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDataFederationPrivateEndpointsExecute") + } + + var r0 *admin.PaginatedPrivateNetworkEndpointIdEntry + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDataFederationPrivateEndpointsApiRequest) *admin.PaginatedPrivateNetworkEndpointIdEntry); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedPrivateNetworkEndpointIdEntry) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDataFederationPrivateEndpointsApiRequest) *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.ListDataFederationPrivateEndpointsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDataFederationPrivateEndpointsExecute' +type DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call struct { + *mock.Call +} + +// ListDataFederationPrivateEndpointsExecute is a helper method to define mock.On call +// - r admin.ListDataFederationPrivateEndpointsApiRequest +func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpointsExecute(r interface{}) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call { + return &DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call{Call: _e.mock.On("ListDataFederationPrivateEndpointsExecute", r)} +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) Run(run func(r admin.ListDataFederationPrivateEndpointsApiRequest)) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDataFederationPrivateEndpointsApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) Return(_a0 *admin.PaginatedPrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) RunAndReturn(run func(admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDataFederationPrivateEndpointsWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) ListDataFederationPrivateEndpointsWithParams(ctx context.Context, args *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDataFederationPrivateEndpointsWithParams") + } + + var r0 admin.ListDataFederationPrivateEndpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDataFederationPrivateEndpointsApiRequest) + } + + return r0 +} + +// DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDataFederationPrivateEndpointsWithParams' +type DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call struct { + *mock.Call +} + +// ListDataFederationPrivateEndpointsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDataFederationPrivateEndpointsApiParams +func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpointsWithParams(ctx interface{}, args interface{}) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call { + return &DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call{Call: _e.mock.On("ListDataFederationPrivateEndpointsWithParams", ctx, args)} +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDataFederationPrivateEndpointsApiParams)) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDataFederationPrivateEndpointsApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) Return(_a0 admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListFederatedDatabases provides a mock function with given fields: ctx, groupId +func (_m *DataFederationApi) ListFederatedDatabases(ctx context.Context, groupId string) admin.ListFederatedDatabasesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListFederatedDatabases") + } + + var r0 admin.ListFederatedDatabasesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListFederatedDatabasesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListFederatedDatabasesApiRequest) + } + + return r0 +} + +// DataFederationApi_ListFederatedDatabases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFederatedDatabases' +type DataFederationApi_ListFederatedDatabases_Call struct { + *mock.Call +} + +// ListFederatedDatabases is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *DataFederationApi_Expecter) ListFederatedDatabases(ctx interface{}, groupId interface{}) *DataFederationApi_ListFederatedDatabases_Call { + return &DataFederationApi_ListFederatedDatabases_Call{Call: _e.mock.On("ListFederatedDatabases", ctx, groupId)} +} + +func (_c *DataFederationApi_ListFederatedDatabases_Call) Run(run func(ctx context.Context, groupId string)) *DataFederationApi_ListFederatedDatabases_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabases_Call) Return(_a0 admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabases_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabases_Call) RunAndReturn(run func(context.Context, string) admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabases_Call { + _c.Call.Return(run) + return _c +} + +// ListFederatedDatabasesExecute provides a mock function with given fields: r +func (_m *DataFederationApi) ListFederatedDatabasesExecute(r admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListFederatedDatabasesExecute") + } + + var r0 []admin.DataLakeTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListFederatedDatabasesApiRequest) []admin.DataLakeTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.DataLakeTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListFederatedDatabasesApiRequest) *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.ListFederatedDatabasesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_ListFederatedDatabasesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFederatedDatabasesExecute' +type DataFederationApi_ListFederatedDatabasesExecute_Call struct { + *mock.Call +} + +// ListFederatedDatabasesExecute is a helper method to define mock.On call +// - r admin.ListFederatedDatabasesApiRequest +func (_e *DataFederationApi_Expecter) ListFederatedDatabasesExecute(r interface{}) *DataFederationApi_ListFederatedDatabasesExecute_Call { + return &DataFederationApi_ListFederatedDatabasesExecute_Call{Call: _e.mock.On("ListFederatedDatabasesExecute", r)} +} + +func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) Run(run func(r admin.ListFederatedDatabasesApiRequest)) *DataFederationApi_ListFederatedDatabasesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListFederatedDatabasesApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) Return(_a0 []admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_ListFederatedDatabasesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) RunAndReturn(run func(admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_ListFederatedDatabasesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListFederatedDatabasesWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) ListFederatedDatabasesWithParams(ctx context.Context, args *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListFederatedDatabasesWithParams") + } + + var r0 admin.ListFederatedDatabasesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListFederatedDatabasesApiRequest) + } + + return r0 +} + +// DataFederationApi_ListFederatedDatabasesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFederatedDatabasesWithParams' +type DataFederationApi_ListFederatedDatabasesWithParams_Call struct { + *mock.Call +} + +// ListFederatedDatabasesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListFederatedDatabasesApiParams +func (_e *DataFederationApi_Expecter) ListFederatedDatabasesWithParams(ctx interface{}, args interface{}) *DataFederationApi_ListFederatedDatabasesWithParams_Call { + return &DataFederationApi_ListFederatedDatabasesWithParams_Call{Call: _e.mock.On("ListFederatedDatabasesWithParams", ctx, args)} +} + +func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListFederatedDatabasesApiParams)) *DataFederationApi_ListFederatedDatabasesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListFederatedDatabasesApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) Return(_a0 admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabasesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabasesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string) admin.ReturnFederatedDatabaseQueryLimitApiRequest { + ret := _m.Called(ctx, groupId, tenantName, limitName) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimit") + } + + var r0 admin.ReturnFederatedDatabaseQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.ReturnFederatedDatabaseQueryLimitApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, limitName) + } else { + r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimit' +type DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimit is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - limitName string +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimit", ctx, groupId, tenantName, limitName)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string)) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_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 *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string) admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimitExecute provides a mock function with given fields: r +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitExecute(r admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimitExecute") + } + + var r0 *admin.DataFederationTenantQueryLimit + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) *admin.DataFederationTenantQueryLimit); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataFederationTenantQueryLimit) + } + } + + if rf, ok := ret.Get(1).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) *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.ReturnFederatedDatabaseQueryLimitApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimitExecute' +type DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimitExecute is a helper method to define mock.On call +// - r admin.ReturnFederatedDatabaseQueryLimitApiRequest +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitExecute(r interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitExecute", r)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) Run(run func(r admin.ReturnFederatedDatabaseQueryLimitApiRequest)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ReturnFederatedDatabaseQueryLimitApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) Return(_a0 *admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) RunAndReturn(run func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimitWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitWithParams(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimitWithParams") + } + + var r0 admin.ReturnFederatedDatabaseQueryLimitApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitApiRequest) + } + + return r0 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimitWithParams' +type DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimitWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ReturnFederatedDatabaseQueryLimitApiParams +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitWithParams", ctx, args)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitApiParams)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ReturnFederatedDatabaseQueryLimitApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimits provides a mock function with given fields: ctx, groupId, tenantName +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimits(ctx context.Context, groupId string, tenantName string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimits") + } + + var r0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) + } + + return r0 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimits' +type DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimits is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimits(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimits", ctx, groupId, tenantName)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call) RunAndReturn(run func(context.Context, string, string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimitsExecute provides a mock function with given fields: r +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitsExecute(r admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimitsExecute") + } + + var r0 []admin.DataFederationTenantQueryLimit + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) []admin.DataFederationTenantQueryLimit); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.DataFederationTenantQueryLimit) + } + } + + if rf, ok := ret.Get(1).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *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.ReturnFederatedDatabaseQueryLimitsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimitsExecute' +type DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimitsExecute is a helper method to define mock.On call +// - r admin.ReturnFederatedDatabaseQueryLimitsApiRequest +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitsExecute(r interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitsExecute", r)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) Run(run func(r admin.ReturnFederatedDatabaseQueryLimitsApiRequest)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ReturnFederatedDatabaseQueryLimitsApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) Return(_a0 []admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) RunAndReturn(run func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ReturnFederatedDatabaseQueryLimitsWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitsWithParams(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ReturnFederatedDatabaseQueryLimitsWithParams") + } + + var r0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) + } + + return r0 +} + +// DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnFederatedDatabaseQueryLimitsWithParams' +type DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call struct { + *mock.Call +} + +// ReturnFederatedDatabaseQueryLimitsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ReturnFederatedDatabaseQueryLimitsApiParams +func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitsWithParams(ctx interface{}, args interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call { + return &DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitsWithParams", ctx, args)} +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitsApiParams)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ReturnFederatedDatabaseQueryLimitsApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName, dataLakeTenant +func (_m *DataFederationApi) UpdateFederatedDatabase(ctx context.Context, groupId string, tenantName string, dataLakeTenant *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest { + ret := _m.Called(ctx, groupId, tenantName, dataLakeTenant) + + if len(ret) == 0 { + panic("no return value specified for UpdateFederatedDatabase") + } + + var r0 admin.UpdateFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, dataLakeTenant) + } else { + r0 = ret.Get(0).(admin.UpdateFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_UpdateFederatedDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFederatedDatabase' +type DataFederationApi_UpdateFederatedDatabase_Call struct { + *mock.Call +} + +// UpdateFederatedDatabase is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - dataLakeTenant *admin.DataLakeTenant +func (_e *DataFederationApi_Expecter) UpdateFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}, dataLakeTenant interface{}) *DataFederationApi_UpdateFederatedDatabase_Call { + return &DataFederationApi_UpdateFederatedDatabase_Call{Call: _e.mock.On("UpdateFederatedDatabase", ctx, groupId, tenantName, dataLakeTenant)} +} + +func (_c *DataFederationApi_UpdateFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, tenantName string, dataLakeTenant *admin.DataLakeTenant)) *DataFederationApi_UpdateFederatedDatabase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DataLakeTenant)) + }) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabase_Call) Return(_a0 admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string, *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabase_Call { + _c.Call.Return(run) + return _c +} + +// UpdateFederatedDatabaseExecute provides a mock function with given fields: r +func (_m *DataFederationApi) UpdateFederatedDatabaseExecute(r admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateFederatedDatabaseExecute") + } + + var r0 *admin.DataLakeTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateFederatedDatabaseApiRequest) *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.UpdateFederatedDatabaseApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataFederationApi_UpdateFederatedDatabaseExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFederatedDatabaseExecute' +type DataFederationApi_UpdateFederatedDatabaseExecute_Call struct { + *mock.Call +} + +// UpdateFederatedDatabaseExecute is a helper method to define mock.On call +// - r admin.UpdateFederatedDatabaseApiRequest +func (_e *DataFederationApi_Expecter) UpdateFederatedDatabaseExecute(r interface{}) *DataFederationApi_UpdateFederatedDatabaseExecute_Call { + return &DataFederationApi_UpdateFederatedDatabaseExecute_Call{Call: _e.mock.On("UpdateFederatedDatabaseExecute", r)} +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) Run(run func(r admin.UpdateFederatedDatabaseApiRequest)) *DataFederationApi_UpdateFederatedDatabaseExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateFederatedDatabaseApiRequest)) + }) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_UpdateFederatedDatabaseExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_UpdateFederatedDatabaseExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateFederatedDatabaseWithParams provides a mock function with given fields: ctx, args +func (_m *DataFederationApi) UpdateFederatedDatabaseWithParams(ctx context.Context, args *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateFederatedDatabaseWithParams") + } + + var r0 admin.UpdateFederatedDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateFederatedDatabaseApiRequest) + } + + return r0 +} + +// DataFederationApi_UpdateFederatedDatabaseWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFederatedDatabaseWithParams' +type DataFederationApi_UpdateFederatedDatabaseWithParams_Call struct { + *mock.Call +} + +// UpdateFederatedDatabaseWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateFederatedDatabaseApiParams +func (_e *DataFederationApi_Expecter) UpdateFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call { + return &DataFederationApi_UpdateFederatedDatabaseWithParams_Call{Call: _e.mock.On("UpdateFederatedDatabaseWithParams", ctx, args)} +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateFederatedDatabaseApiParams)) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateFederatedDatabaseApiParams)) + }) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) Return(_a0 admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewDataFederationApi creates a new instance of DataFederationApi. 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 NewDataFederationApi(t interface { + mock.TestingT + Cleanup(func()) +}) *DataFederationApi { + mock := &DataFederationApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/data_lake_pipelines_api.go b/mockadmin/data_lake_pipelines_api.go new file mode 100644 index 000000000..e9e23ccec --- /dev/null +++ b/mockadmin/data_lake_pipelines_api.go @@ -0,0 +1,2149 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// DataLakePipelinesApi is an autogenerated mock type for the DataLakePipelinesApi type +type DataLakePipelinesApi struct { + mock.Mock +} + +type DataLakePipelinesApi_Expecter struct { + mock *mock.Mock +} + +func (_m *DataLakePipelinesApi) EXPECT() *DataLakePipelinesApi_Expecter { + return &DataLakePipelinesApi_Expecter{mock: &_m.Mock} +} + +// CreatePipeline provides a mock function with given fields: ctx, groupId, dataLakeIngestionPipeline +func (_m *DataLakePipelinesApi) CreatePipeline(ctx context.Context, groupId string, dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline) admin.CreatePipelineApiRequest { + ret := _m.Called(ctx, groupId, dataLakeIngestionPipeline) + + if len(ret) == 0 { + panic("no return value specified for CreatePipeline") + } + + var r0 admin.CreatePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.DataLakeIngestionPipeline) admin.CreatePipelineApiRequest); ok { + r0 = rf(ctx, groupId, dataLakeIngestionPipeline) + } else { + r0 = ret.Get(0).(admin.CreatePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_CreatePipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePipeline' +type DataLakePipelinesApi_CreatePipeline_Call struct { + *mock.Call +} + +// CreatePipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline +func (_e *DataLakePipelinesApi_Expecter) CreatePipeline(ctx interface{}, groupId interface{}, dataLakeIngestionPipeline interface{}) *DataLakePipelinesApi_CreatePipeline_Call { + return &DataLakePipelinesApi_CreatePipeline_Call{Call: _e.mock.On("CreatePipeline", ctx, groupId, dataLakeIngestionPipeline)} +} + +func (_c *DataLakePipelinesApi_CreatePipeline_Call) Run(run func(ctx context.Context, groupId string, dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline)) *DataLakePipelinesApi_CreatePipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.DataLakeIngestionPipeline)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipeline_Call) Return(_a0 admin.CreatePipelineApiRequest) *DataLakePipelinesApi_CreatePipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipeline_Call) RunAndReturn(run func(context.Context, string, *admin.DataLakeIngestionPipeline) admin.CreatePipelineApiRequest) *DataLakePipelinesApi_CreatePipeline_Call { + _c.Call.Return(run) + return _c +} + +// CreatePipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) CreatePipelineExecute(r admin.CreatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePipelineExecute") + } + + var r0 *admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePipelineApiRequest) *admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePipelineApiRequest) *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.CreatePipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_CreatePipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePipelineExecute' +type DataLakePipelinesApi_CreatePipelineExecute_Call struct { + *mock.Call +} + +// CreatePipelineExecute is a helper method to define mock.On call +// - r admin.CreatePipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) CreatePipelineExecute(r interface{}) *DataLakePipelinesApi_CreatePipelineExecute_Call { + return &DataLakePipelinesApi_CreatePipelineExecute_Call{Call: _e.mock.On("CreatePipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_CreatePipelineExecute_Call) Run(run func(r admin.CreatePipelineApiRequest)) *DataLakePipelinesApi_CreatePipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipelineExecute_Call) Return(_a0 *admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_CreatePipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipelineExecute_Call) RunAndReturn(run func(admin.CreatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_CreatePipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) CreatePipelineWithParams(ctx context.Context, args *admin.CreatePipelineApiParams) admin.CreatePipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePipelineWithParams") + } + + var r0 admin.CreatePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePipelineApiParams) admin.CreatePipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_CreatePipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePipelineWithParams' +type DataLakePipelinesApi_CreatePipelineWithParams_Call struct { + *mock.Call +} + +// CreatePipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) CreatePipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_CreatePipelineWithParams_Call { + return &DataLakePipelinesApi_CreatePipelineWithParams_Call{Call: _e.mock.On("CreatePipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_CreatePipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePipelineApiParams)) *DataLakePipelinesApi_CreatePipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipelineWithParams_Call) Return(_a0 admin.CreatePipelineApiRequest) *DataLakePipelinesApi_CreatePipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_CreatePipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePipelineApiParams) admin.CreatePipelineApiRequest) *DataLakePipelinesApi_CreatePipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipeline provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) DeletePipeline(ctx context.Context, groupId string, pipelineName string) admin.DeletePipelineApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for DeletePipeline") + } + + var r0 admin.DeletePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeletePipelineApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.DeletePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_DeletePipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipeline' +type DataLakePipelinesApi_DeletePipeline_Call struct { + *mock.Call +} + +// DeletePipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) DeletePipeline(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_DeletePipeline_Call { + return &DataLakePipelinesApi_DeletePipeline_Call{Call: _e.mock.On("DeletePipeline", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_DeletePipeline_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_DeletePipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipeline_Call) Return(_a0 admin.DeletePipelineApiRequest) *DataLakePipelinesApi_DeletePipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipeline_Call) RunAndReturn(run func(context.Context, string, string) admin.DeletePipelineApiRequest) *DataLakePipelinesApi_DeletePipeline_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) DeletePipelineExecute(r admin.DeletePipelineApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePipelineExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePipelineApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePipelineApiRequest) 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.DeletePipelineApiRequest) *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.DeletePipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_DeletePipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipelineExecute' +type DataLakePipelinesApi_DeletePipelineExecute_Call struct { + *mock.Call +} + +// DeletePipelineExecute is a helper method to define mock.On call +// - r admin.DeletePipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) DeletePipelineExecute(r interface{}) *DataLakePipelinesApi_DeletePipelineExecute_Call { + return &DataLakePipelinesApi_DeletePipelineExecute_Call{Call: _e.mock.On("DeletePipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_DeletePipelineExecute_Call) Run(run func(r admin.DeletePipelineApiRequest)) *DataLakePipelinesApi_DeletePipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_DeletePipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineExecute_Call) RunAndReturn(run func(admin.DeletePipelineApiRequest) (map[string]interface{}, *http.Response, error)) *DataLakePipelinesApi_DeletePipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipelineRunDataset provides a mock function with given fields: ctx, groupId, pipelineName, pipelineRunId +func (_m *DataLakePipelinesApi) DeletePipelineRunDataset(ctx context.Context, groupId string, pipelineName string, pipelineRunId string) admin.DeletePipelineRunDatasetApiRequest { + ret := _m.Called(ctx, groupId, pipelineName, pipelineRunId) + + if len(ret) == 0 { + panic("no return value specified for DeletePipelineRunDataset") + } + + var r0 admin.DeletePipelineRunDatasetApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeletePipelineRunDatasetApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName, pipelineRunId) + } else { + r0 = ret.Get(0).(admin.DeletePipelineRunDatasetApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_DeletePipelineRunDataset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipelineRunDataset' +type DataLakePipelinesApi_DeletePipelineRunDataset_Call struct { + *mock.Call +} + +// DeletePipelineRunDataset is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +// - pipelineRunId string +func (_e *DataLakePipelinesApi_Expecter) DeletePipelineRunDataset(ctx interface{}, groupId interface{}, pipelineName interface{}, pipelineRunId interface{}) *DataLakePipelinesApi_DeletePipelineRunDataset_Call { + return &DataLakePipelinesApi_DeletePipelineRunDataset_Call{Call: _e.mock.On("DeletePipelineRunDataset", ctx, groupId, pipelineName, pipelineRunId)} +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDataset_Call) Run(run func(ctx context.Context, groupId string, pipelineName string, pipelineRunId string)) *DataLakePipelinesApi_DeletePipelineRunDataset_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 *DataLakePipelinesApi_DeletePipelineRunDataset_Call) Return(_a0 admin.DeletePipelineRunDatasetApiRequest) *DataLakePipelinesApi_DeletePipelineRunDataset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDataset_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeletePipelineRunDatasetApiRequest) *DataLakePipelinesApi_DeletePipelineRunDataset_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipelineRunDatasetExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) DeletePipelineRunDatasetExecute(r admin.DeletePipelineRunDatasetApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePipelineRunDatasetExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePipelineRunDatasetApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePipelineRunDatasetApiRequest) 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.DeletePipelineRunDatasetApiRequest) *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.DeletePipelineRunDatasetApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipelineRunDatasetExecute' +type DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call struct { + *mock.Call +} + +// DeletePipelineRunDatasetExecute is a helper method to define mock.On call +// - r admin.DeletePipelineRunDatasetApiRequest +func (_e *DataLakePipelinesApi_Expecter) DeletePipelineRunDatasetExecute(r interface{}) *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call { + return &DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call{Call: _e.mock.On("DeletePipelineRunDatasetExecute", r)} +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call) Run(run func(r admin.DeletePipelineRunDatasetApiRequest)) *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePipelineRunDatasetApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call) RunAndReturn(run func(admin.DeletePipelineRunDatasetApiRequest) (map[string]interface{}, *http.Response, error)) *DataLakePipelinesApi_DeletePipelineRunDatasetExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipelineRunDatasetWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) DeletePipelineRunDatasetWithParams(ctx context.Context, args *admin.DeletePipelineRunDatasetApiParams) admin.DeletePipelineRunDatasetApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePipelineRunDatasetWithParams") + } + + var r0 admin.DeletePipelineRunDatasetApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePipelineRunDatasetApiParams) admin.DeletePipelineRunDatasetApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePipelineRunDatasetApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipelineRunDatasetWithParams' +type DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call struct { + *mock.Call +} + +// DeletePipelineRunDatasetWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePipelineRunDatasetApiParams +func (_e *DataLakePipelinesApi_Expecter) DeletePipelineRunDatasetWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call { + return &DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call{Call: _e.mock.On("DeletePipelineRunDatasetWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePipelineRunDatasetApiParams)) *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePipelineRunDatasetApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call) Return(_a0 admin.DeletePipelineRunDatasetApiRequest) *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePipelineRunDatasetApiParams) admin.DeletePipelineRunDatasetApiRequest) *DataLakePipelinesApi_DeletePipelineRunDatasetWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) DeletePipelineWithParams(ctx context.Context, args *admin.DeletePipelineApiParams) admin.DeletePipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePipelineWithParams") + } + + var r0 admin.DeletePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePipelineApiParams) admin.DeletePipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_DeletePipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePipelineWithParams' +type DataLakePipelinesApi_DeletePipelineWithParams_Call struct { + *mock.Call +} + +// DeletePipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) DeletePipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_DeletePipelineWithParams_Call { + return &DataLakePipelinesApi_DeletePipelineWithParams_Call{Call: _e.mock.On("DeletePipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_DeletePipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePipelineApiParams)) *DataLakePipelinesApi_DeletePipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineWithParams_Call) Return(_a0 admin.DeletePipelineApiRequest) *DataLakePipelinesApi_DeletePipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_DeletePipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePipelineApiParams) admin.DeletePipelineApiRequest) *DataLakePipelinesApi_DeletePipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPipeline provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) GetPipeline(ctx context.Context, groupId string, pipelineName string) admin.GetPipelineApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for GetPipeline") + } + + var r0 admin.GetPipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetPipelineApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.GetPipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_GetPipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipeline' +type DataLakePipelinesApi_GetPipeline_Call struct { + *mock.Call +} + +// GetPipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) GetPipeline(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_GetPipeline_Call { + return &DataLakePipelinesApi_GetPipeline_Call{Call: _e.mock.On("GetPipeline", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_GetPipeline_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_GetPipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipeline_Call) Return(_a0 admin.GetPipelineApiRequest) *DataLakePipelinesApi_GetPipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipeline_Call) RunAndReturn(run func(context.Context, string, string) admin.GetPipelineApiRequest) *DataLakePipelinesApi_GetPipeline_Call { + _c.Call.Return(run) + return _c +} + +// GetPipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) GetPipelineExecute(r admin.GetPipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPipelineExecute") + } + + var r0 *admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPipelineApiRequest) *admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPipelineApiRequest) *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.GetPipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_GetPipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipelineExecute' +type DataLakePipelinesApi_GetPipelineExecute_Call struct { + *mock.Call +} + +// GetPipelineExecute is a helper method to define mock.On call +// - r admin.GetPipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) GetPipelineExecute(r interface{}) *DataLakePipelinesApi_GetPipelineExecute_Call { + return &DataLakePipelinesApi_GetPipelineExecute_Call{Call: _e.mock.On("GetPipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_GetPipelineExecute_Call) Run(run func(r admin.GetPipelineApiRequest)) *DataLakePipelinesApi_GetPipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineExecute_Call) Return(_a0 *admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_GetPipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineExecute_Call) RunAndReturn(run func(admin.GetPipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_GetPipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPipelineRun provides a mock function with given fields: ctx, groupId, pipelineName, pipelineRunId +func (_m *DataLakePipelinesApi) GetPipelineRun(ctx context.Context, groupId string, pipelineName string, pipelineRunId string) admin.GetPipelineRunApiRequest { + ret := _m.Called(ctx, groupId, pipelineName, pipelineRunId) + + if len(ret) == 0 { + panic("no return value specified for GetPipelineRun") + } + + var r0 admin.GetPipelineRunApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetPipelineRunApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName, pipelineRunId) + } else { + r0 = ret.Get(0).(admin.GetPipelineRunApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_GetPipelineRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipelineRun' +type DataLakePipelinesApi_GetPipelineRun_Call struct { + *mock.Call +} + +// GetPipelineRun is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +// - pipelineRunId string +func (_e *DataLakePipelinesApi_Expecter) GetPipelineRun(ctx interface{}, groupId interface{}, pipelineName interface{}, pipelineRunId interface{}) *DataLakePipelinesApi_GetPipelineRun_Call { + return &DataLakePipelinesApi_GetPipelineRun_Call{Call: _e.mock.On("GetPipelineRun", ctx, groupId, pipelineName, pipelineRunId)} +} + +func (_c *DataLakePipelinesApi_GetPipelineRun_Call) Run(run func(ctx context.Context, groupId string, pipelineName string, pipelineRunId string)) *DataLakePipelinesApi_GetPipelineRun_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 *DataLakePipelinesApi_GetPipelineRun_Call) Return(_a0 admin.GetPipelineRunApiRequest) *DataLakePipelinesApi_GetPipelineRun_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineRun_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetPipelineRunApiRequest) *DataLakePipelinesApi_GetPipelineRun_Call { + _c.Call.Return(run) + return _c +} + +// GetPipelineRunExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) GetPipelineRunExecute(r admin.GetPipelineRunApiRequest) (*admin.IngestionPipelineRun, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPipelineRunExecute") + } + + var r0 *admin.IngestionPipelineRun + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPipelineRunApiRequest) (*admin.IngestionPipelineRun, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPipelineRunApiRequest) *admin.IngestionPipelineRun); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.IngestionPipelineRun) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPipelineRunApiRequest) *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.GetPipelineRunApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_GetPipelineRunExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipelineRunExecute' +type DataLakePipelinesApi_GetPipelineRunExecute_Call struct { + *mock.Call +} + +// GetPipelineRunExecute is a helper method to define mock.On call +// - r admin.GetPipelineRunApiRequest +func (_e *DataLakePipelinesApi_Expecter) GetPipelineRunExecute(r interface{}) *DataLakePipelinesApi_GetPipelineRunExecute_Call { + return &DataLakePipelinesApi_GetPipelineRunExecute_Call{Call: _e.mock.On("GetPipelineRunExecute", r)} +} + +func (_c *DataLakePipelinesApi_GetPipelineRunExecute_Call) Run(run func(r admin.GetPipelineRunApiRequest)) *DataLakePipelinesApi_GetPipelineRunExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPipelineRunApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineRunExecute_Call) Return(_a0 *admin.IngestionPipelineRun, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_GetPipelineRunExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineRunExecute_Call) RunAndReturn(run func(admin.GetPipelineRunApiRequest) (*admin.IngestionPipelineRun, *http.Response, error)) *DataLakePipelinesApi_GetPipelineRunExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPipelineRunWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) GetPipelineRunWithParams(ctx context.Context, args *admin.GetPipelineRunApiParams) admin.GetPipelineRunApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPipelineRunWithParams") + } + + var r0 admin.GetPipelineRunApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPipelineRunApiParams) admin.GetPipelineRunApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPipelineRunApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_GetPipelineRunWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipelineRunWithParams' +type DataLakePipelinesApi_GetPipelineRunWithParams_Call struct { + *mock.Call +} + +// GetPipelineRunWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPipelineRunApiParams +func (_e *DataLakePipelinesApi_Expecter) GetPipelineRunWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_GetPipelineRunWithParams_Call { + return &DataLakePipelinesApi_GetPipelineRunWithParams_Call{Call: _e.mock.On("GetPipelineRunWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_GetPipelineRunWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPipelineRunApiParams)) *DataLakePipelinesApi_GetPipelineRunWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPipelineRunApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineRunWithParams_Call) Return(_a0 admin.GetPipelineRunApiRequest) *DataLakePipelinesApi_GetPipelineRunWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineRunWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPipelineRunApiParams) admin.GetPipelineRunApiRequest) *DataLakePipelinesApi_GetPipelineRunWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) GetPipelineWithParams(ctx context.Context, args *admin.GetPipelineApiParams) admin.GetPipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPipelineWithParams") + } + + var r0 admin.GetPipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPipelineApiParams) admin.GetPipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_GetPipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPipelineWithParams' +type DataLakePipelinesApi_GetPipelineWithParams_Call struct { + *mock.Call +} + +// GetPipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) GetPipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_GetPipelineWithParams_Call { + return &DataLakePipelinesApi_GetPipelineWithParams_Call{Call: _e.mock.On("GetPipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_GetPipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPipelineApiParams)) *DataLakePipelinesApi_GetPipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineWithParams_Call) Return(_a0 admin.GetPipelineApiRequest) *DataLakePipelinesApi_GetPipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_GetPipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPipelineApiParams) admin.GetPipelineApiRequest) *DataLakePipelinesApi_GetPipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineRuns provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) ListPipelineRuns(ctx context.Context, groupId string, pipelineName string) admin.ListPipelineRunsApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineRuns") + } + + var r0 admin.ListPipelineRunsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListPipelineRunsApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.ListPipelineRunsApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineRuns' +type DataLakePipelinesApi_ListPipelineRuns_Call struct { + *mock.Call +} + +// ListPipelineRuns is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) ListPipelineRuns(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_ListPipelineRuns_Call { + return &DataLakePipelinesApi_ListPipelineRuns_Call{Call: _e.mock.On("ListPipelineRuns", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_ListPipelineRuns_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_ListPipelineRuns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRuns_Call) Return(_a0 admin.ListPipelineRunsApiRequest) *DataLakePipelinesApi_ListPipelineRuns_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRuns_Call) RunAndReturn(run func(context.Context, string, string) admin.ListPipelineRunsApiRequest) *DataLakePipelinesApi_ListPipelineRuns_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineRunsExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) ListPipelineRunsExecute(r admin.ListPipelineRunsApiRequest) (*admin.PaginatedPipelineRun, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineRunsExecute") + } + + var r0 *admin.PaginatedPipelineRun + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPipelineRunsApiRequest) (*admin.PaginatedPipelineRun, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPipelineRunsApiRequest) *admin.PaginatedPipelineRun); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedPipelineRun) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPipelineRunsApiRequest) *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.ListPipelineRunsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_ListPipelineRunsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineRunsExecute' +type DataLakePipelinesApi_ListPipelineRunsExecute_Call struct { + *mock.Call +} + +// ListPipelineRunsExecute is a helper method to define mock.On call +// - r admin.ListPipelineRunsApiRequest +func (_e *DataLakePipelinesApi_Expecter) ListPipelineRunsExecute(r interface{}) *DataLakePipelinesApi_ListPipelineRunsExecute_Call { + return &DataLakePipelinesApi_ListPipelineRunsExecute_Call{Call: _e.mock.On("ListPipelineRunsExecute", r)} +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsExecute_Call) Run(run func(r admin.ListPipelineRunsApiRequest)) *DataLakePipelinesApi_ListPipelineRunsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPipelineRunsApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsExecute_Call) Return(_a0 *admin.PaginatedPipelineRun, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_ListPipelineRunsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsExecute_Call) RunAndReturn(run func(admin.ListPipelineRunsApiRequest) (*admin.PaginatedPipelineRun, *http.Response, error)) *DataLakePipelinesApi_ListPipelineRunsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineRunsWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) ListPipelineRunsWithParams(ctx context.Context, args *admin.ListPipelineRunsApiParams) admin.ListPipelineRunsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineRunsWithParams") + } + + var r0 admin.ListPipelineRunsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPipelineRunsApiParams) admin.ListPipelineRunsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPipelineRunsApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineRunsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineRunsWithParams' +type DataLakePipelinesApi_ListPipelineRunsWithParams_Call struct { + *mock.Call +} + +// ListPipelineRunsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPipelineRunsApiParams +func (_e *DataLakePipelinesApi_Expecter) ListPipelineRunsWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_ListPipelineRunsWithParams_Call { + return &DataLakePipelinesApi_ListPipelineRunsWithParams_Call{Call: _e.mock.On("ListPipelineRunsWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPipelineRunsApiParams)) *DataLakePipelinesApi_ListPipelineRunsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPipelineRunsApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsWithParams_Call) Return(_a0 admin.ListPipelineRunsApiRequest) *DataLakePipelinesApi_ListPipelineRunsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineRunsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPipelineRunsApiParams) admin.ListPipelineRunsApiRequest) *DataLakePipelinesApi_ListPipelineRunsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSchedules provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) ListPipelineSchedules(ctx context.Context, groupId string, pipelineName string) admin.ListPipelineSchedulesApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSchedules") + } + + var r0 admin.ListPipelineSchedulesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListPipelineSchedulesApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.ListPipelineSchedulesApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineSchedules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSchedules' +type DataLakePipelinesApi_ListPipelineSchedules_Call struct { + *mock.Call +} + +// ListPipelineSchedules is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSchedules(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_ListPipelineSchedules_Call { + return &DataLakePipelinesApi_ListPipelineSchedules_Call{Call: _e.mock.On("ListPipelineSchedules", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedules_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_ListPipelineSchedules_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedules_Call) Return(_a0 admin.ListPipelineSchedulesApiRequest) *DataLakePipelinesApi_ListPipelineSchedules_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedules_Call) RunAndReturn(run func(context.Context, string, string) admin.ListPipelineSchedulesApiRequest) *DataLakePipelinesApi_ListPipelineSchedules_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSchedulesExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) ListPipelineSchedulesExecute(r admin.ListPipelineSchedulesApiRequest) ([]admin.DiskBackupApiPolicyItem, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSchedulesExecute") + } + + var r0 []admin.DiskBackupApiPolicyItem + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPipelineSchedulesApiRequest) ([]admin.DiskBackupApiPolicyItem, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPipelineSchedulesApiRequest) []admin.DiskBackupApiPolicyItem); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.DiskBackupApiPolicyItem) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPipelineSchedulesApiRequest) *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.ListPipelineSchedulesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_ListPipelineSchedulesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSchedulesExecute' +type DataLakePipelinesApi_ListPipelineSchedulesExecute_Call struct { + *mock.Call +} + +// ListPipelineSchedulesExecute is a helper method to define mock.On call +// - r admin.ListPipelineSchedulesApiRequest +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSchedulesExecute(r interface{}) *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call { + return &DataLakePipelinesApi_ListPipelineSchedulesExecute_Call{Call: _e.mock.On("ListPipelineSchedulesExecute", r)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call) Run(run func(r admin.ListPipelineSchedulesApiRequest)) *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPipelineSchedulesApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call) Return(_a0 []admin.DiskBackupApiPolicyItem, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call) RunAndReturn(run func(admin.ListPipelineSchedulesApiRequest) ([]admin.DiskBackupApiPolicyItem, *http.Response, error)) *DataLakePipelinesApi_ListPipelineSchedulesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSchedulesWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) ListPipelineSchedulesWithParams(ctx context.Context, args *admin.ListPipelineSchedulesApiParams) admin.ListPipelineSchedulesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSchedulesWithParams") + } + + var r0 admin.ListPipelineSchedulesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPipelineSchedulesApiParams) admin.ListPipelineSchedulesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPipelineSchedulesApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSchedulesWithParams' +type DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call struct { + *mock.Call +} + +// ListPipelineSchedulesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPipelineSchedulesApiParams +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSchedulesWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call { + return &DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call{Call: _e.mock.On("ListPipelineSchedulesWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPipelineSchedulesApiParams)) *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPipelineSchedulesApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call) Return(_a0 admin.ListPipelineSchedulesApiRequest) *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPipelineSchedulesApiParams) admin.ListPipelineSchedulesApiRequest) *DataLakePipelinesApi_ListPipelineSchedulesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSnapshots provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) ListPipelineSnapshots(ctx context.Context, groupId string, pipelineName string) admin.ListPipelineSnapshotsApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSnapshots") + } + + var r0 admin.ListPipelineSnapshotsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListPipelineSnapshotsApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.ListPipelineSnapshotsApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSnapshots' +type DataLakePipelinesApi_ListPipelineSnapshots_Call struct { + *mock.Call +} + +// ListPipelineSnapshots is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSnapshots(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_ListPipelineSnapshots_Call { + return &DataLakePipelinesApi_ListPipelineSnapshots_Call{Call: _e.mock.On("ListPipelineSnapshots", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshots_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_ListPipelineSnapshots_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshots_Call) Return(_a0 admin.ListPipelineSnapshotsApiRequest) *DataLakePipelinesApi_ListPipelineSnapshots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshots_Call) RunAndReturn(run func(context.Context, string, string) admin.ListPipelineSnapshotsApiRequest) *DataLakePipelinesApi_ListPipelineSnapshots_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSnapshotsExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) ListPipelineSnapshotsExecute(r admin.ListPipelineSnapshotsApiRequest) (*admin.PaginatedBackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSnapshotsExecute") + } + + var r0 *admin.PaginatedBackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPipelineSnapshotsApiRequest) (*admin.PaginatedBackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPipelineSnapshotsApiRequest) *admin.PaginatedBackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedBackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPipelineSnapshotsApiRequest) *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.ListPipelineSnapshotsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSnapshotsExecute' +type DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call struct { + *mock.Call +} + +// ListPipelineSnapshotsExecute is a helper method to define mock.On call +// - r admin.ListPipelineSnapshotsApiRequest +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSnapshotsExecute(r interface{}) *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call { + return &DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call{Call: _e.mock.On("ListPipelineSnapshotsExecute", r)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call) Run(run func(r admin.ListPipelineSnapshotsApiRequest)) *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPipelineSnapshotsApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call) Return(_a0 *admin.PaginatedBackupSnapshot, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call) RunAndReturn(run func(admin.ListPipelineSnapshotsApiRequest) (*admin.PaginatedBackupSnapshot, *http.Response, error)) *DataLakePipelinesApi_ListPipelineSnapshotsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelineSnapshotsWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) ListPipelineSnapshotsWithParams(ctx context.Context, args *admin.ListPipelineSnapshotsApiParams) admin.ListPipelineSnapshotsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPipelineSnapshotsWithParams") + } + + var r0 admin.ListPipelineSnapshotsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPipelineSnapshotsApiParams) admin.ListPipelineSnapshotsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPipelineSnapshotsApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelineSnapshotsWithParams' +type DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call struct { + *mock.Call +} + +// ListPipelineSnapshotsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPipelineSnapshotsApiParams +func (_e *DataLakePipelinesApi_Expecter) ListPipelineSnapshotsWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call { + return &DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call{Call: _e.mock.On("ListPipelineSnapshotsWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPipelineSnapshotsApiParams)) *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPipelineSnapshotsApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call) Return(_a0 admin.ListPipelineSnapshotsApiRequest) *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPipelineSnapshotsApiParams) admin.ListPipelineSnapshotsApiRequest) *DataLakePipelinesApi_ListPipelineSnapshotsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelines provides a mock function with given fields: ctx, groupId +func (_m *DataLakePipelinesApi) ListPipelines(ctx context.Context, groupId string) admin.ListPipelinesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListPipelines") + } + + var r0 admin.ListPipelinesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListPipelinesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListPipelinesApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelines_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelines' +type DataLakePipelinesApi_ListPipelines_Call struct { + *mock.Call +} + +// ListPipelines is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *DataLakePipelinesApi_Expecter) ListPipelines(ctx interface{}, groupId interface{}) *DataLakePipelinesApi_ListPipelines_Call { + return &DataLakePipelinesApi_ListPipelines_Call{Call: _e.mock.On("ListPipelines", ctx, groupId)} +} + +func (_c *DataLakePipelinesApi_ListPipelines_Call) Run(run func(ctx context.Context, groupId string)) *DataLakePipelinesApi_ListPipelines_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelines_Call) Return(_a0 admin.ListPipelinesApiRequest) *DataLakePipelinesApi_ListPipelines_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelines_Call) RunAndReturn(run func(context.Context, string) admin.ListPipelinesApiRequest) *DataLakePipelinesApi_ListPipelines_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelinesExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) ListPipelinesExecute(r admin.ListPipelinesApiRequest) ([]admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPipelinesExecute") + } + + var r0 []admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPipelinesApiRequest) ([]admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPipelinesApiRequest) []admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPipelinesApiRequest) *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.ListPipelinesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_ListPipelinesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelinesExecute' +type DataLakePipelinesApi_ListPipelinesExecute_Call struct { + *mock.Call +} + +// ListPipelinesExecute is a helper method to define mock.On call +// - r admin.ListPipelinesApiRequest +func (_e *DataLakePipelinesApi_Expecter) ListPipelinesExecute(r interface{}) *DataLakePipelinesApi_ListPipelinesExecute_Call { + return &DataLakePipelinesApi_ListPipelinesExecute_Call{Call: _e.mock.On("ListPipelinesExecute", r)} +} + +func (_c *DataLakePipelinesApi_ListPipelinesExecute_Call) Run(run func(r admin.ListPipelinesApiRequest)) *DataLakePipelinesApi_ListPipelinesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPipelinesApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelinesExecute_Call) Return(_a0 []admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_ListPipelinesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelinesExecute_Call) RunAndReturn(run func(admin.ListPipelinesApiRequest) ([]admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_ListPipelinesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPipelinesWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) ListPipelinesWithParams(ctx context.Context, args *admin.ListPipelinesApiParams) admin.ListPipelinesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPipelinesWithParams") + } + + var r0 admin.ListPipelinesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPipelinesApiParams) admin.ListPipelinesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPipelinesApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ListPipelinesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPipelinesWithParams' +type DataLakePipelinesApi_ListPipelinesWithParams_Call struct { + *mock.Call +} + +// ListPipelinesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPipelinesApiParams +func (_e *DataLakePipelinesApi_Expecter) ListPipelinesWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_ListPipelinesWithParams_Call { + return &DataLakePipelinesApi_ListPipelinesWithParams_Call{Call: _e.mock.On("ListPipelinesWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_ListPipelinesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPipelinesApiParams)) *DataLakePipelinesApi_ListPipelinesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPipelinesApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelinesWithParams_Call) Return(_a0 admin.ListPipelinesApiRequest) *DataLakePipelinesApi_ListPipelinesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ListPipelinesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPipelinesApiParams) admin.ListPipelinesApiRequest) *DataLakePipelinesApi_ListPipelinesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// PausePipeline provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) PausePipeline(ctx context.Context, groupId string, pipelineName string) admin.PausePipelineApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for PausePipeline") + } + + var r0 admin.PausePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.PausePipelineApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.PausePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_PausePipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PausePipeline' +type DataLakePipelinesApi_PausePipeline_Call struct { + *mock.Call +} + +// PausePipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) PausePipeline(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_PausePipeline_Call { + return &DataLakePipelinesApi_PausePipeline_Call{Call: _e.mock.On("PausePipeline", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_PausePipeline_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_PausePipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipeline_Call) Return(_a0 admin.PausePipelineApiRequest) *DataLakePipelinesApi_PausePipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipeline_Call) RunAndReturn(run func(context.Context, string, string) admin.PausePipelineApiRequest) *DataLakePipelinesApi_PausePipeline_Call { + _c.Call.Return(run) + return _c +} + +// PausePipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) PausePipelineExecute(r admin.PausePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for PausePipelineExecute") + } + + var r0 *admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.PausePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.PausePipelineApiRequest) *admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.PausePipelineApiRequest) *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.PausePipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_PausePipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PausePipelineExecute' +type DataLakePipelinesApi_PausePipelineExecute_Call struct { + *mock.Call +} + +// PausePipelineExecute is a helper method to define mock.On call +// - r admin.PausePipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) PausePipelineExecute(r interface{}) *DataLakePipelinesApi_PausePipelineExecute_Call { + return &DataLakePipelinesApi_PausePipelineExecute_Call{Call: _e.mock.On("PausePipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_PausePipelineExecute_Call) Run(run func(r admin.PausePipelineApiRequest)) *DataLakePipelinesApi_PausePipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.PausePipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipelineExecute_Call) Return(_a0 *admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_PausePipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipelineExecute_Call) RunAndReturn(run func(admin.PausePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_PausePipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// PausePipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) PausePipelineWithParams(ctx context.Context, args *admin.PausePipelineApiParams) admin.PausePipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for PausePipelineWithParams") + } + + var r0 admin.PausePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.PausePipelineApiParams) admin.PausePipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.PausePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_PausePipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PausePipelineWithParams' +type DataLakePipelinesApi_PausePipelineWithParams_Call struct { + *mock.Call +} + +// PausePipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.PausePipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) PausePipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_PausePipelineWithParams_Call { + return &DataLakePipelinesApi_PausePipelineWithParams_Call{Call: _e.mock.On("PausePipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_PausePipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.PausePipelineApiParams)) *DataLakePipelinesApi_PausePipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.PausePipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipelineWithParams_Call) Return(_a0 admin.PausePipelineApiRequest) *DataLakePipelinesApi_PausePipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_PausePipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.PausePipelineApiParams) admin.PausePipelineApiRequest) *DataLakePipelinesApi_PausePipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ResumePipeline provides a mock function with given fields: ctx, groupId, pipelineName +func (_m *DataLakePipelinesApi) ResumePipeline(ctx context.Context, groupId string, pipelineName string) admin.ResumePipelineApiRequest { + ret := _m.Called(ctx, groupId, pipelineName) + + if len(ret) == 0 { + panic("no return value specified for ResumePipeline") + } + + var r0 admin.ResumePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ResumePipelineApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName) + } else { + r0 = ret.Get(0).(admin.ResumePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ResumePipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumePipeline' +type DataLakePipelinesApi_ResumePipeline_Call struct { + *mock.Call +} + +// ResumePipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +func (_e *DataLakePipelinesApi_Expecter) ResumePipeline(ctx interface{}, groupId interface{}, pipelineName interface{}) *DataLakePipelinesApi_ResumePipeline_Call { + return &DataLakePipelinesApi_ResumePipeline_Call{Call: _e.mock.On("ResumePipeline", ctx, groupId, pipelineName)} +} + +func (_c *DataLakePipelinesApi_ResumePipeline_Call) Run(run func(ctx context.Context, groupId string, pipelineName string)) *DataLakePipelinesApi_ResumePipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipeline_Call) Return(_a0 admin.ResumePipelineApiRequest) *DataLakePipelinesApi_ResumePipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipeline_Call) RunAndReturn(run func(context.Context, string, string) admin.ResumePipelineApiRequest) *DataLakePipelinesApi_ResumePipeline_Call { + _c.Call.Return(run) + return _c +} + +// ResumePipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) ResumePipelineExecute(r admin.ResumePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ResumePipelineExecute") + } + + var r0 *admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ResumePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ResumePipelineApiRequest) *admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.ResumePipelineApiRequest) *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.ResumePipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_ResumePipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumePipelineExecute' +type DataLakePipelinesApi_ResumePipelineExecute_Call struct { + *mock.Call +} + +// ResumePipelineExecute is a helper method to define mock.On call +// - r admin.ResumePipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) ResumePipelineExecute(r interface{}) *DataLakePipelinesApi_ResumePipelineExecute_Call { + return &DataLakePipelinesApi_ResumePipelineExecute_Call{Call: _e.mock.On("ResumePipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_ResumePipelineExecute_Call) Run(run func(r admin.ResumePipelineApiRequest)) *DataLakePipelinesApi_ResumePipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ResumePipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipelineExecute_Call) Return(_a0 *admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_ResumePipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipelineExecute_Call) RunAndReturn(run func(admin.ResumePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_ResumePipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// ResumePipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) ResumePipelineWithParams(ctx context.Context, args *admin.ResumePipelineApiParams) admin.ResumePipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ResumePipelineWithParams") + } + + var r0 admin.ResumePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ResumePipelineApiParams) admin.ResumePipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ResumePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_ResumePipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumePipelineWithParams' +type DataLakePipelinesApi_ResumePipelineWithParams_Call struct { + *mock.Call +} + +// ResumePipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ResumePipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) ResumePipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_ResumePipelineWithParams_Call { + return &DataLakePipelinesApi_ResumePipelineWithParams_Call{Call: _e.mock.On("ResumePipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_ResumePipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.ResumePipelineApiParams)) *DataLakePipelinesApi_ResumePipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ResumePipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipelineWithParams_Call) Return(_a0 admin.ResumePipelineApiRequest) *DataLakePipelinesApi_ResumePipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_ResumePipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.ResumePipelineApiParams) admin.ResumePipelineApiRequest) *DataLakePipelinesApi_ResumePipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// TriggerSnapshotIngestion provides a mock function with given fields: ctx, groupId, pipelineName, triggerIngestionPipelineRequest +func (_m *DataLakePipelinesApi) TriggerSnapshotIngestion(ctx context.Context, groupId string, pipelineName string, triggerIngestionPipelineRequest *admin.TriggerIngestionPipelineRequest) admin.TriggerSnapshotIngestionApiRequest { + ret := _m.Called(ctx, groupId, pipelineName, triggerIngestionPipelineRequest) + + if len(ret) == 0 { + panic("no return value specified for TriggerSnapshotIngestion") + } + + var r0 admin.TriggerSnapshotIngestionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TriggerIngestionPipelineRequest) admin.TriggerSnapshotIngestionApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName, triggerIngestionPipelineRequest) + } else { + r0 = ret.Get(0).(admin.TriggerSnapshotIngestionApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_TriggerSnapshotIngestion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TriggerSnapshotIngestion' +type DataLakePipelinesApi_TriggerSnapshotIngestion_Call struct { + *mock.Call +} + +// TriggerSnapshotIngestion is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +// - triggerIngestionPipelineRequest *admin.TriggerIngestionPipelineRequest +func (_e *DataLakePipelinesApi_Expecter) TriggerSnapshotIngestion(ctx interface{}, groupId interface{}, pipelineName interface{}, triggerIngestionPipelineRequest interface{}) *DataLakePipelinesApi_TriggerSnapshotIngestion_Call { + return &DataLakePipelinesApi_TriggerSnapshotIngestion_Call{Call: _e.mock.On("TriggerSnapshotIngestion", ctx, groupId, pipelineName, triggerIngestionPipelineRequest)} +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestion_Call) Run(run func(ctx context.Context, groupId string, pipelineName string, triggerIngestionPipelineRequest *admin.TriggerIngestionPipelineRequest)) *DataLakePipelinesApi_TriggerSnapshotIngestion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TriggerIngestionPipelineRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestion_Call) Return(_a0 admin.TriggerSnapshotIngestionApiRequest) *DataLakePipelinesApi_TriggerSnapshotIngestion_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestion_Call) RunAndReturn(run func(context.Context, string, string, *admin.TriggerIngestionPipelineRequest) admin.TriggerSnapshotIngestionApiRequest) *DataLakePipelinesApi_TriggerSnapshotIngestion_Call { + _c.Call.Return(run) + return _c +} + +// TriggerSnapshotIngestionExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) TriggerSnapshotIngestionExecute(r admin.TriggerSnapshotIngestionApiRequest) (*admin.IngestionPipelineRun, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for TriggerSnapshotIngestionExecute") + } + + var r0 *admin.IngestionPipelineRun + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.TriggerSnapshotIngestionApiRequest) (*admin.IngestionPipelineRun, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.TriggerSnapshotIngestionApiRequest) *admin.IngestionPipelineRun); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.IngestionPipelineRun) + } + } + + if rf, ok := ret.Get(1).(func(admin.TriggerSnapshotIngestionApiRequest) *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.TriggerSnapshotIngestionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TriggerSnapshotIngestionExecute' +type DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call struct { + *mock.Call +} + +// TriggerSnapshotIngestionExecute is a helper method to define mock.On call +// - r admin.TriggerSnapshotIngestionApiRequest +func (_e *DataLakePipelinesApi_Expecter) TriggerSnapshotIngestionExecute(r interface{}) *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call { + return &DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call{Call: _e.mock.On("TriggerSnapshotIngestionExecute", r)} +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call) Run(run func(r admin.TriggerSnapshotIngestionApiRequest)) *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.TriggerSnapshotIngestionApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call) Return(_a0 *admin.IngestionPipelineRun, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call) RunAndReturn(run func(admin.TriggerSnapshotIngestionApiRequest) (*admin.IngestionPipelineRun, *http.Response, error)) *DataLakePipelinesApi_TriggerSnapshotIngestionExecute_Call { + _c.Call.Return(run) + return _c +} + +// TriggerSnapshotIngestionWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) TriggerSnapshotIngestionWithParams(ctx context.Context, args *admin.TriggerSnapshotIngestionApiParams) admin.TriggerSnapshotIngestionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for TriggerSnapshotIngestionWithParams") + } + + var r0 admin.TriggerSnapshotIngestionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.TriggerSnapshotIngestionApiParams) admin.TriggerSnapshotIngestionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.TriggerSnapshotIngestionApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TriggerSnapshotIngestionWithParams' +type DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call struct { + *mock.Call +} + +// TriggerSnapshotIngestionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.TriggerSnapshotIngestionApiParams +func (_e *DataLakePipelinesApi_Expecter) TriggerSnapshotIngestionWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call { + return &DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call{Call: _e.mock.On("TriggerSnapshotIngestionWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call) Run(run func(ctx context.Context, args *admin.TriggerSnapshotIngestionApiParams)) *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.TriggerSnapshotIngestionApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call) Return(_a0 admin.TriggerSnapshotIngestionApiRequest) *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call) RunAndReturn(run func(context.Context, *admin.TriggerSnapshotIngestionApiParams) admin.TriggerSnapshotIngestionApiRequest) *DataLakePipelinesApi_TriggerSnapshotIngestionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePipeline provides a mock function with given fields: ctx, groupId, pipelineName, dataLakeIngestionPipeline +func (_m *DataLakePipelinesApi) UpdatePipeline(ctx context.Context, groupId string, pipelineName string, dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline) admin.UpdatePipelineApiRequest { + ret := _m.Called(ctx, groupId, pipelineName, dataLakeIngestionPipeline) + + if len(ret) == 0 { + panic("no return value specified for UpdatePipeline") + } + + var r0 admin.UpdatePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DataLakeIngestionPipeline) admin.UpdatePipelineApiRequest); ok { + r0 = rf(ctx, groupId, pipelineName, dataLakeIngestionPipeline) + } else { + r0 = ret.Get(0).(admin.UpdatePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_UpdatePipeline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePipeline' +type DataLakePipelinesApi_UpdatePipeline_Call struct { + *mock.Call +} + +// UpdatePipeline is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pipelineName string +// - dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline +func (_e *DataLakePipelinesApi_Expecter) UpdatePipeline(ctx interface{}, groupId interface{}, pipelineName interface{}, dataLakeIngestionPipeline interface{}) *DataLakePipelinesApi_UpdatePipeline_Call { + return &DataLakePipelinesApi_UpdatePipeline_Call{Call: _e.mock.On("UpdatePipeline", ctx, groupId, pipelineName, dataLakeIngestionPipeline)} +} + +func (_c *DataLakePipelinesApi_UpdatePipeline_Call) Run(run func(ctx context.Context, groupId string, pipelineName string, dataLakeIngestionPipeline *admin.DataLakeIngestionPipeline)) *DataLakePipelinesApi_UpdatePipeline_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DataLakeIngestionPipeline)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipeline_Call) Return(_a0 admin.UpdatePipelineApiRequest) *DataLakePipelinesApi_UpdatePipeline_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipeline_Call) RunAndReturn(run func(context.Context, string, string, *admin.DataLakeIngestionPipeline) admin.UpdatePipelineApiRequest) *DataLakePipelinesApi_UpdatePipeline_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePipelineExecute provides a mock function with given fields: r +func (_m *DataLakePipelinesApi) UpdatePipelineExecute(r admin.UpdatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdatePipelineExecute") + } + + var r0 *admin.DataLakeIngestionPipeline + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdatePipelineApiRequest) *admin.DataLakeIngestionPipeline); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.DataLakeIngestionPipeline) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdatePipelineApiRequest) *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.UpdatePipelineApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DataLakePipelinesApi_UpdatePipelineExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePipelineExecute' +type DataLakePipelinesApi_UpdatePipelineExecute_Call struct { + *mock.Call +} + +// UpdatePipelineExecute is a helper method to define mock.On call +// - r admin.UpdatePipelineApiRequest +func (_e *DataLakePipelinesApi_Expecter) UpdatePipelineExecute(r interface{}) *DataLakePipelinesApi_UpdatePipelineExecute_Call { + return &DataLakePipelinesApi_UpdatePipelineExecute_Call{Call: _e.mock.On("UpdatePipelineExecute", r)} +} + +func (_c *DataLakePipelinesApi_UpdatePipelineExecute_Call) Run(run func(r admin.UpdatePipelineApiRequest)) *DataLakePipelinesApi_UpdatePipelineExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdatePipelineApiRequest)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipelineExecute_Call) Return(_a0 *admin.DataLakeIngestionPipeline, _a1 *http.Response, _a2 error) *DataLakePipelinesApi_UpdatePipelineExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipelineExecute_Call) RunAndReturn(run func(admin.UpdatePipelineApiRequest) (*admin.DataLakeIngestionPipeline, *http.Response, error)) *DataLakePipelinesApi_UpdatePipelineExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePipelineWithParams provides a mock function with given fields: ctx, args +func (_m *DataLakePipelinesApi) UpdatePipelineWithParams(ctx context.Context, args *admin.UpdatePipelineApiParams) admin.UpdatePipelineApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdatePipelineWithParams") + } + + var r0 admin.UpdatePipelineApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdatePipelineApiParams) admin.UpdatePipelineApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdatePipelineApiRequest) + } + + return r0 +} + +// DataLakePipelinesApi_UpdatePipelineWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePipelineWithParams' +type DataLakePipelinesApi_UpdatePipelineWithParams_Call struct { + *mock.Call +} + +// UpdatePipelineWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdatePipelineApiParams +func (_e *DataLakePipelinesApi_Expecter) UpdatePipelineWithParams(ctx interface{}, args interface{}) *DataLakePipelinesApi_UpdatePipelineWithParams_Call { + return &DataLakePipelinesApi_UpdatePipelineWithParams_Call{Call: _e.mock.On("UpdatePipelineWithParams", ctx, args)} +} + +func (_c *DataLakePipelinesApi_UpdatePipelineWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdatePipelineApiParams)) *DataLakePipelinesApi_UpdatePipelineWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdatePipelineApiParams)) + }) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipelineWithParams_Call) Return(_a0 admin.UpdatePipelineApiRequest) *DataLakePipelinesApi_UpdatePipelineWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DataLakePipelinesApi_UpdatePipelineWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdatePipelineApiParams) admin.UpdatePipelineApiRequest) *DataLakePipelinesApi_UpdatePipelineWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewDataLakePipelinesApi creates a new instance of DataLakePipelinesApi. 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 NewDataLakePipelinesApi(t interface { + mock.TestingT + Cleanup(func()) +}) *DataLakePipelinesApi { + mock := &DataLakePipelinesApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/database_users_api.go b/mockadmin/database_users_api.go new file mode 100644 index 000000000..8ec2f2b4a --- /dev/null +++ b/mockadmin/database_users_api.go @@ -0,0 +1,853 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// DatabaseUsersApi is an autogenerated mock type for the DatabaseUsersApi type +type DatabaseUsersApi struct { + mock.Mock +} + +type DatabaseUsersApi_Expecter struct { + mock *mock.Mock +} + +func (_m *DatabaseUsersApi) EXPECT() *DatabaseUsersApi_Expecter { + return &DatabaseUsersApi_Expecter{mock: &_m.Mock} +} + +// CreateDatabaseUser provides a mock function with given fields: ctx, groupId, cloudDatabaseUser +func (_m *DatabaseUsersApi) CreateDatabaseUser(ctx context.Context, groupId string, cloudDatabaseUser *admin.CloudDatabaseUser) admin.CreateDatabaseUserApiRequest { + ret := _m.Called(ctx, groupId, cloudDatabaseUser) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUser") + } + + var r0 admin.CreateDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CloudDatabaseUser) admin.CreateDatabaseUserApiRequest); ok { + r0 = rf(ctx, groupId, cloudDatabaseUser) + } else { + r0 = ret.Get(0).(admin.CreateDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_CreateDatabaseUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUser' +type DatabaseUsersApi_CreateDatabaseUser_Call struct { + *mock.Call +} + +// CreateDatabaseUser is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudDatabaseUser *admin.CloudDatabaseUser +func (_e *DatabaseUsersApi_Expecter) CreateDatabaseUser(ctx interface{}, groupId interface{}, cloudDatabaseUser interface{}) *DatabaseUsersApi_CreateDatabaseUser_Call { + return &DatabaseUsersApi_CreateDatabaseUser_Call{Call: _e.mock.On("CreateDatabaseUser", ctx, groupId, cloudDatabaseUser)} +} + +func (_c *DatabaseUsersApi_CreateDatabaseUser_Call) Run(run func(ctx context.Context, groupId string, cloudDatabaseUser *admin.CloudDatabaseUser)) *DatabaseUsersApi_CreateDatabaseUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CloudDatabaseUser)) + }) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUser_Call) Return(_a0 admin.CreateDatabaseUserApiRequest) *DatabaseUsersApi_CreateDatabaseUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUser_Call) RunAndReturn(run func(context.Context, string, *admin.CloudDatabaseUser) admin.CreateDatabaseUserApiRequest) *DatabaseUsersApi_CreateDatabaseUser_Call { + _c.Call.Return(run) + return _c +} + +// CreateDatabaseUserExecute provides a mock function with given fields: r +func (_m *DatabaseUsersApi) CreateDatabaseUserExecute(r admin.CreateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUserExecute") + } + + var r0 *admin.CloudDatabaseUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateDatabaseUserApiRequest) *admin.CloudDatabaseUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudDatabaseUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateDatabaseUserApiRequest) *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.CreateDatabaseUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DatabaseUsersApi_CreateDatabaseUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUserExecute' +type DatabaseUsersApi_CreateDatabaseUserExecute_Call struct { + *mock.Call +} + +// CreateDatabaseUserExecute is a helper method to define mock.On call +// - r admin.CreateDatabaseUserApiRequest +func (_e *DatabaseUsersApi_Expecter) CreateDatabaseUserExecute(r interface{}) *DatabaseUsersApi_CreateDatabaseUserExecute_Call { + return &DatabaseUsersApi_CreateDatabaseUserExecute_Call{Call: _e.mock.On("CreateDatabaseUserExecute", r)} +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserExecute_Call) Run(run func(r admin.CreateDatabaseUserApiRequest)) *DatabaseUsersApi_CreateDatabaseUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateDatabaseUserApiRequest)) + }) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserExecute_Call) Return(_a0 *admin.CloudDatabaseUser, _a1 *http.Response, _a2 error) *DatabaseUsersApi_CreateDatabaseUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserExecute_Call) RunAndReturn(run func(admin.CreateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)) *DatabaseUsersApi_CreateDatabaseUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateDatabaseUserWithParams provides a mock function with given fields: ctx, args +func (_m *DatabaseUsersApi) CreateDatabaseUserWithParams(ctx context.Context, args *admin.CreateDatabaseUserApiParams) admin.CreateDatabaseUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUserWithParams") + } + + var r0 admin.CreateDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateDatabaseUserApiParams) admin.CreateDatabaseUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_CreateDatabaseUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUserWithParams' +type DatabaseUsersApi_CreateDatabaseUserWithParams_Call struct { + *mock.Call +} + +// CreateDatabaseUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateDatabaseUserApiParams +func (_e *DatabaseUsersApi_Expecter) CreateDatabaseUserWithParams(ctx interface{}, args interface{}) *DatabaseUsersApi_CreateDatabaseUserWithParams_Call { + return &DatabaseUsersApi_CreateDatabaseUserWithParams_Call{Call: _e.mock.On("CreateDatabaseUserWithParams", ctx, args)} +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateDatabaseUserApiParams)) *DatabaseUsersApi_CreateDatabaseUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateDatabaseUserApiParams)) + }) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserWithParams_Call) Return(_a0 admin.CreateDatabaseUserApiRequest) *DatabaseUsersApi_CreateDatabaseUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_CreateDatabaseUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateDatabaseUserApiParams) admin.CreateDatabaseUserApiRequest) *DatabaseUsersApi_CreateDatabaseUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDatabaseUser provides a mock function with given fields: ctx, groupId, databaseName, username +func (_m *DatabaseUsersApi) DeleteDatabaseUser(ctx context.Context, groupId string, databaseName string, username string) admin.DeleteDatabaseUserApiRequest { + ret := _m.Called(ctx, groupId, databaseName, username) + + if len(ret) == 0 { + panic("no return value specified for DeleteDatabaseUser") + } + + var r0 admin.DeleteDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteDatabaseUserApiRequest); ok { + r0 = rf(ctx, groupId, databaseName, username) + } else { + r0 = ret.Get(0).(admin.DeleteDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_DeleteDatabaseUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDatabaseUser' +type DatabaseUsersApi_DeleteDatabaseUser_Call struct { + *mock.Call +} + +// DeleteDatabaseUser is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - databaseName string +// - username string +func (_e *DatabaseUsersApi_Expecter) DeleteDatabaseUser(ctx interface{}, groupId interface{}, databaseName interface{}, username interface{}) *DatabaseUsersApi_DeleteDatabaseUser_Call { + return &DatabaseUsersApi_DeleteDatabaseUser_Call{Call: _e.mock.On("DeleteDatabaseUser", ctx, groupId, databaseName, username)} +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUser_Call) Run(run func(ctx context.Context, groupId string, databaseName string, username string)) *DatabaseUsersApi_DeleteDatabaseUser_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 *DatabaseUsersApi_DeleteDatabaseUser_Call) Return(_a0 admin.DeleteDatabaseUserApiRequest) *DatabaseUsersApi_DeleteDatabaseUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUser_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteDatabaseUserApiRequest) *DatabaseUsersApi_DeleteDatabaseUser_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDatabaseUserExecute provides a mock function with given fields: r +func (_m *DatabaseUsersApi) DeleteDatabaseUserExecute(r admin.DeleteDatabaseUserApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteDatabaseUserExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteDatabaseUserApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteDatabaseUserApiRequest) 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.DeleteDatabaseUserApiRequest) *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.DeleteDatabaseUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DatabaseUsersApi_DeleteDatabaseUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDatabaseUserExecute' +type DatabaseUsersApi_DeleteDatabaseUserExecute_Call struct { + *mock.Call +} + +// DeleteDatabaseUserExecute is a helper method to define mock.On call +// - r admin.DeleteDatabaseUserApiRequest +func (_e *DatabaseUsersApi_Expecter) DeleteDatabaseUserExecute(r interface{}) *DatabaseUsersApi_DeleteDatabaseUserExecute_Call { + return &DatabaseUsersApi_DeleteDatabaseUserExecute_Call{Call: _e.mock.On("DeleteDatabaseUserExecute", r)} +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserExecute_Call) Run(run func(r admin.DeleteDatabaseUserApiRequest)) *DatabaseUsersApi_DeleteDatabaseUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteDatabaseUserApiRequest)) + }) + return _c +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DatabaseUsersApi_DeleteDatabaseUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserExecute_Call) RunAndReturn(run func(admin.DeleteDatabaseUserApiRequest) (map[string]interface{}, *http.Response, error)) *DatabaseUsersApi_DeleteDatabaseUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteDatabaseUserWithParams provides a mock function with given fields: ctx, args +func (_m *DatabaseUsersApi) DeleteDatabaseUserWithParams(ctx context.Context, args *admin.DeleteDatabaseUserApiParams) admin.DeleteDatabaseUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteDatabaseUserWithParams") + } + + var r0 admin.DeleteDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteDatabaseUserApiParams) admin.DeleteDatabaseUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_DeleteDatabaseUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDatabaseUserWithParams' +type DatabaseUsersApi_DeleteDatabaseUserWithParams_Call struct { + *mock.Call +} + +// DeleteDatabaseUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteDatabaseUserApiParams +func (_e *DatabaseUsersApi_Expecter) DeleteDatabaseUserWithParams(ctx interface{}, args interface{}) *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call { + return &DatabaseUsersApi_DeleteDatabaseUserWithParams_Call{Call: _e.mock.On("DeleteDatabaseUserWithParams", ctx, args)} +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteDatabaseUserApiParams)) *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteDatabaseUserApiParams)) + }) + return _c +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call) Return(_a0 admin.DeleteDatabaseUserApiRequest) *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteDatabaseUserApiParams) admin.DeleteDatabaseUserApiRequest) *DatabaseUsersApi_DeleteDatabaseUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseUser provides a mock function with given fields: ctx, groupId, databaseName, username +func (_m *DatabaseUsersApi) GetDatabaseUser(ctx context.Context, groupId string, databaseName string, username string) admin.GetDatabaseUserApiRequest { + ret := _m.Called(ctx, groupId, databaseName, username) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseUser") + } + + var r0 admin.GetDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetDatabaseUserApiRequest); ok { + r0 = rf(ctx, groupId, databaseName, username) + } else { + r0 = ret.Get(0).(admin.GetDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_GetDatabaseUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseUser' +type DatabaseUsersApi_GetDatabaseUser_Call struct { + *mock.Call +} + +// GetDatabaseUser is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - databaseName string +// - username string +func (_e *DatabaseUsersApi_Expecter) GetDatabaseUser(ctx interface{}, groupId interface{}, databaseName interface{}, username interface{}) *DatabaseUsersApi_GetDatabaseUser_Call { + return &DatabaseUsersApi_GetDatabaseUser_Call{Call: _e.mock.On("GetDatabaseUser", ctx, groupId, databaseName, username)} +} + +func (_c *DatabaseUsersApi_GetDatabaseUser_Call) Run(run func(ctx context.Context, groupId string, databaseName string, username string)) *DatabaseUsersApi_GetDatabaseUser_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 *DatabaseUsersApi_GetDatabaseUser_Call) Return(_a0 admin.GetDatabaseUserApiRequest) *DatabaseUsersApi_GetDatabaseUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_GetDatabaseUser_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetDatabaseUserApiRequest) *DatabaseUsersApi_GetDatabaseUser_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseUserExecute provides a mock function with given fields: r +func (_m *DatabaseUsersApi) GetDatabaseUserExecute(r admin.GetDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseUserExecute") + } + + var r0 *admin.CloudDatabaseUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDatabaseUserApiRequest) *admin.CloudDatabaseUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudDatabaseUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDatabaseUserApiRequest) *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.GetDatabaseUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DatabaseUsersApi_GetDatabaseUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseUserExecute' +type DatabaseUsersApi_GetDatabaseUserExecute_Call struct { + *mock.Call +} + +// GetDatabaseUserExecute is a helper method to define mock.On call +// - r admin.GetDatabaseUserApiRequest +func (_e *DatabaseUsersApi_Expecter) GetDatabaseUserExecute(r interface{}) *DatabaseUsersApi_GetDatabaseUserExecute_Call { + return &DatabaseUsersApi_GetDatabaseUserExecute_Call{Call: _e.mock.On("GetDatabaseUserExecute", r)} +} + +func (_c *DatabaseUsersApi_GetDatabaseUserExecute_Call) Run(run func(r admin.GetDatabaseUserApiRequest)) *DatabaseUsersApi_GetDatabaseUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDatabaseUserApiRequest)) + }) + return _c +} + +func (_c *DatabaseUsersApi_GetDatabaseUserExecute_Call) Return(_a0 *admin.CloudDatabaseUser, _a1 *http.Response, _a2 error) *DatabaseUsersApi_GetDatabaseUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DatabaseUsersApi_GetDatabaseUserExecute_Call) RunAndReturn(run func(admin.GetDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)) *DatabaseUsersApi_GetDatabaseUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseUserWithParams provides a mock function with given fields: ctx, args +func (_m *DatabaseUsersApi) GetDatabaseUserWithParams(ctx context.Context, args *admin.GetDatabaseUserApiParams) admin.GetDatabaseUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseUserWithParams") + } + + var r0 admin.GetDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDatabaseUserApiParams) admin.GetDatabaseUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_GetDatabaseUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseUserWithParams' +type DatabaseUsersApi_GetDatabaseUserWithParams_Call struct { + *mock.Call +} + +// GetDatabaseUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDatabaseUserApiParams +func (_e *DatabaseUsersApi_Expecter) GetDatabaseUserWithParams(ctx interface{}, args interface{}) *DatabaseUsersApi_GetDatabaseUserWithParams_Call { + return &DatabaseUsersApi_GetDatabaseUserWithParams_Call{Call: _e.mock.On("GetDatabaseUserWithParams", ctx, args)} +} + +func (_c *DatabaseUsersApi_GetDatabaseUserWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDatabaseUserApiParams)) *DatabaseUsersApi_GetDatabaseUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDatabaseUserApiParams)) + }) + return _c +} + +func (_c *DatabaseUsersApi_GetDatabaseUserWithParams_Call) Return(_a0 admin.GetDatabaseUserApiRequest) *DatabaseUsersApi_GetDatabaseUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_GetDatabaseUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDatabaseUserApiParams) admin.GetDatabaseUserApiRequest) *DatabaseUsersApi_GetDatabaseUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUsers provides a mock function with given fields: ctx, groupId +func (_m *DatabaseUsersApi) ListDatabaseUsers(ctx context.Context, groupId string) admin.ListDatabaseUsersApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUsers") + } + + var r0 admin.ListDatabaseUsersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListDatabaseUsersApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListDatabaseUsersApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_ListDatabaseUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUsers' +type DatabaseUsersApi_ListDatabaseUsers_Call struct { + *mock.Call +} + +// ListDatabaseUsers is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *DatabaseUsersApi_Expecter) ListDatabaseUsers(ctx interface{}, groupId interface{}) *DatabaseUsersApi_ListDatabaseUsers_Call { + return &DatabaseUsersApi_ListDatabaseUsers_Call{Call: _e.mock.On("ListDatabaseUsers", ctx, groupId)} +} + +func (_c *DatabaseUsersApi_ListDatabaseUsers_Call) Run(run func(ctx context.Context, groupId string)) *DatabaseUsersApi_ListDatabaseUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsers_Call) Return(_a0 admin.ListDatabaseUsersApiRequest) *DatabaseUsersApi_ListDatabaseUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsers_Call) RunAndReturn(run func(context.Context, string) admin.ListDatabaseUsersApiRequest) *DatabaseUsersApi_ListDatabaseUsers_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUsersExecute provides a mock function with given fields: r +func (_m *DatabaseUsersApi) ListDatabaseUsersExecute(r admin.ListDatabaseUsersApiRequest) (*admin.PaginatedApiAtlasDatabaseUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUsersExecute") + } + + var r0 *admin.PaginatedApiAtlasDatabaseUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDatabaseUsersApiRequest) (*admin.PaginatedApiAtlasDatabaseUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDatabaseUsersApiRequest) *admin.PaginatedApiAtlasDatabaseUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiAtlasDatabaseUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDatabaseUsersApiRequest) *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.ListDatabaseUsersApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DatabaseUsersApi_ListDatabaseUsersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUsersExecute' +type DatabaseUsersApi_ListDatabaseUsersExecute_Call struct { + *mock.Call +} + +// ListDatabaseUsersExecute is a helper method to define mock.On call +// - r admin.ListDatabaseUsersApiRequest +func (_e *DatabaseUsersApi_Expecter) ListDatabaseUsersExecute(r interface{}) *DatabaseUsersApi_ListDatabaseUsersExecute_Call { + return &DatabaseUsersApi_ListDatabaseUsersExecute_Call{Call: _e.mock.On("ListDatabaseUsersExecute", r)} +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersExecute_Call) Run(run func(r admin.ListDatabaseUsersApiRequest)) *DatabaseUsersApi_ListDatabaseUsersExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDatabaseUsersApiRequest)) + }) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersExecute_Call) Return(_a0 *admin.PaginatedApiAtlasDatabaseUser, _a1 *http.Response, _a2 error) *DatabaseUsersApi_ListDatabaseUsersExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersExecute_Call) RunAndReturn(run func(admin.ListDatabaseUsersApiRequest) (*admin.PaginatedApiAtlasDatabaseUser, *http.Response, error)) *DatabaseUsersApi_ListDatabaseUsersExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUsersWithParams provides a mock function with given fields: ctx, args +func (_m *DatabaseUsersApi) ListDatabaseUsersWithParams(ctx context.Context, args *admin.ListDatabaseUsersApiParams) admin.ListDatabaseUsersApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUsersWithParams") + } + + var r0 admin.ListDatabaseUsersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDatabaseUsersApiParams) admin.ListDatabaseUsersApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDatabaseUsersApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_ListDatabaseUsersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUsersWithParams' +type DatabaseUsersApi_ListDatabaseUsersWithParams_Call struct { + *mock.Call +} + +// ListDatabaseUsersWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDatabaseUsersApiParams +func (_e *DatabaseUsersApi_Expecter) ListDatabaseUsersWithParams(ctx interface{}, args interface{}) *DatabaseUsersApi_ListDatabaseUsersWithParams_Call { + return &DatabaseUsersApi_ListDatabaseUsersWithParams_Call{Call: _e.mock.On("ListDatabaseUsersWithParams", ctx, args)} +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDatabaseUsersApiParams)) *DatabaseUsersApi_ListDatabaseUsersWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDatabaseUsersApiParams)) + }) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersWithParams_Call) Return(_a0 admin.ListDatabaseUsersApiRequest) *DatabaseUsersApi_ListDatabaseUsersWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_ListDatabaseUsersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDatabaseUsersApiParams) admin.ListDatabaseUsersApiRequest) *DatabaseUsersApi_ListDatabaseUsersWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDatabaseUser provides a mock function with given fields: ctx, groupId, databaseName, username, cloudDatabaseUser +func (_m *DatabaseUsersApi) UpdateDatabaseUser(ctx context.Context, groupId string, databaseName string, username string, cloudDatabaseUser *admin.CloudDatabaseUser) admin.UpdateDatabaseUserApiRequest { + ret := _m.Called(ctx, groupId, databaseName, username, cloudDatabaseUser) + + if len(ret) == 0 { + panic("no return value specified for UpdateDatabaseUser") + } + + var r0 admin.UpdateDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.CloudDatabaseUser) admin.UpdateDatabaseUserApiRequest); ok { + r0 = rf(ctx, groupId, databaseName, username, cloudDatabaseUser) + } else { + r0 = ret.Get(0).(admin.UpdateDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_UpdateDatabaseUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDatabaseUser' +type DatabaseUsersApi_UpdateDatabaseUser_Call struct { + *mock.Call +} + +// UpdateDatabaseUser is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - databaseName string +// - username string +// - cloudDatabaseUser *admin.CloudDatabaseUser +func (_e *DatabaseUsersApi_Expecter) UpdateDatabaseUser(ctx interface{}, groupId interface{}, databaseName interface{}, username interface{}, cloudDatabaseUser interface{}) *DatabaseUsersApi_UpdateDatabaseUser_Call { + return &DatabaseUsersApi_UpdateDatabaseUser_Call{Call: _e.mock.On("UpdateDatabaseUser", ctx, groupId, databaseName, username, cloudDatabaseUser)} +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUser_Call) Run(run func(ctx context.Context, groupId string, databaseName string, username string, cloudDatabaseUser *admin.CloudDatabaseUser)) *DatabaseUsersApi_UpdateDatabaseUser_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.CloudDatabaseUser)) + }) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUser_Call) Return(_a0 admin.UpdateDatabaseUserApiRequest) *DatabaseUsersApi_UpdateDatabaseUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUser_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.CloudDatabaseUser) admin.UpdateDatabaseUserApiRequest) *DatabaseUsersApi_UpdateDatabaseUser_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDatabaseUserExecute provides a mock function with given fields: r +func (_m *DatabaseUsersApi) UpdateDatabaseUserExecute(r admin.UpdateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateDatabaseUserExecute") + } + + var r0 *admin.CloudDatabaseUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateDatabaseUserApiRequest) *admin.CloudDatabaseUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudDatabaseUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateDatabaseUserApiRequest) *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.UpdateDatabaseUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// DatabaseUsersApi_UpdateDatabaseUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDatabaseUserExecute' +type DatabaseUsersApi_UpdateDatabaseUserExecute_Call struct { + *mock.Call +} + +// UpdateDatabaseUserExecute is a helper method to define mock.On call +// - r admin.UpdateDatabaseUserApiRequest +func (_e *DatabaseUsersApi_Expecter) UpdateDatabaseUserExecute(r interface{}) *DatabaseUsersApi_UpdateDatabaseUserExecute_Call { + return &DatabaseUsersApi_UpdateDatabaseUserExecute_Call{Call: _e.mock.On("UpdateDatabaseUserExecute", r)} +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserExecute_Call) Run(run func(r admin.UpdateDatabaseUserApiRequest)) *DatabaseUsersApi_UpdateDatabaseUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateDatabaseUserApiRequest)) + }) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserExecute_Call) Return(_a0 *admin.CloudDatabaseUser, _a1 *http.Response, _a2 error) *DatabaseUsersApi_UpdateDatabaseUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserExecute_Call) RunAndReturn(run func(admin.UpdateDatabaseUserApiRequest) (*admin.CloudDatabaseUser, *http.Response, error)) *DatabaseUsersApi_UpdateDatabaseUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDatabaseUserWithParams provides a mock function with given fields: ctx, args +func (_m *DatabaseUsersApi) UpdateDatabaseUserWithParams(ctx context.Context, args *admin.UpdateDatabaseUserApiParams) admin.UpdateDatabaseUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateDatabaseUserWithParams") + } + + var r0 admin.UpdateDatabaseUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateDatabaseUserApiParams) admin.UpdateDatabaseUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateDatabaseUserApiRequest) + } + + return r0 +} + +// DatabaseUsersApi_UpdateDatabaseUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDatabaseUserWithParams' +type DatabaseUsersApi_UpdateDatabaseUserWithParams_Call struct { + *mock.Call +} + +// UpdateDatabaseUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateDatabaseUserApiParams +func (_e *DatabaseUsersApi_Expecter) UpdateDatabaseUserWithParams(ctx interface{}, args interface{}) *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call { + return &DatabaseUsersApi_UpdateDatabaseUserWithParams_Call{Call: _e.mock.On("UpdateDatabaseUserWithParams", ctx, args)} +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateDatabaseUserApiParams)) *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateDatabaseUserApiParams)) + }) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call) Return(_a0 admin.UpdateDatabaseUserApiRequest) *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateDatabaseUserApiParams) admin.UpdateDatabaseUserApiRequest) *DatabaseUsersApi_UpdateDatabaseUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewDatabaseUsersApi creates a new instance of DatabaseUsersApi. 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 NewDatabaseUsersApi(t interface { + mock.TestingT + Cleanup(func()) +}) *DatabaseUsersApi { + mock := &DatabaseUsersApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/encryption_at_rest_using_customer_key_management_api.go b/mockadmin/encryption_at_rest_using_customer_key_management_api.go new file mode 100644 index 000000000..18d61d930 --- /dev/null +++ b/mockadmin/encryption_at_rest_using_customer_key_management_api.go @@ -0,0 +1,363 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +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/mockadmin/events_api.go b/mockadmin/events_api.go new file mode 100644 index 000000000..8d997f220 --- /dev/null +++ b/mockadmin/events_api.go @@ -0,0 +1,686 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// EventsApi is an autogenerated mock type for the EventsApi type +type EventsApi struct { + mock.Mock +} + +type EventsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *EventsApi) EXPECT() *EventsApi_Expecter { + return &EventsApi_Expecter{mock: &_m.Mock} +} + +// GetOrganizationEvent provides a mock function with given fields: ctx, orgId, eventId +func (_m *EventsApi) GetOrganizationEvent(ctx context.Context, orgId string, eventId string) admin.GetOrganizationEventApiRequest { + ret := _m.Called(ctx, orgId, eventId) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationEvent") + } + + var r0 admin.GetOrganizationEventApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetOrganizationEventApiRequest); ok { + r0 = rf(ctx, orgId, eventId) + } else { + r0 = ret.Get(0).(admin.GetOrganizationEventApiRequest) + } + + return r0 +} + +// EventsApi_GetOrganizationEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationEvent' +type EventsApi_GetOrganizationEvent_Call struct { + *mock.Call +} + +// GetOrganizationEvent is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - eventId string +func (_e *EventsApi_Expecter) GetOrganizationEvent(ctx interface{}, orgId interface{}, eventId interface{}) *EventsApi_GetOrganizationEvent_Call { + return &EventsApi_GetOrganizationEvent_Call{Call: _e.mock.On("GetOrganizationEvent", ctx, orgId, eventId)} +} + +func (_c *EventsApi_GetOrganizationEvent_Call) Run(run func(ctx context.Context, orgId string, eventId string)) *EventsApi_GetOrganizationEvent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *EventsApi_GetOrganizationEvent_Call) Return(_a0 admin.GetOrganizationEventApiRequest) *EventsApi_GetOrganizationEvent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_GetOrganizationEvent_Call) RunAndReturn(run func(context.Context, string, string) admin.GetOrganizationEventApiRequest) *EventsApi_GetOrganizationEvent_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationEventExecute provides a mock function with given fields: r +func (_m *EventsApi) GetOrganizationEventExecute(r admin.GetOrganizationEventApiRequest) (*admin.EventViewForOrg, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationEventExecute") + } + + var r0 *admin.EventViewForOrg + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOrganizationEventApiRequest) (*admin.EventViewForOrg, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOrganizationEventApiRequest) *admin.EventViewForOrg); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.EventViewForOrg) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetOrganizationEventApiRequest) *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.GetOrganizationEventApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// EventsApi_GetOrganizationEventExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationEventExecute' +type EventsApi_GetOrganizationEventExecute_Call struct { + *mock.Call +} + +// GetOrganizationEventExecute is a helper method to define mock.On call +// - r admin.GetOrganizationEventApiRequest +func (_e *EventsApi_Expecter) GetOrganizationEventExecute(r interface{}) *EventsApi_GetOrganizationEventExecute_Call { + return &EventsApi_GetOrganizationEventExecute_Call{Call: _e.mock.On("GetOrganizationEventExecute", r)} +} + +func (_c *EventsApi_GetOrganizationEventExecute_Call) Run(run func(r admin.GetOrganizationEventApiRequest)) *EventsApi_GetOrganizationEventExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOrganizationEventApiRequest)) + }) + return _c +} + +func (_c *EventsApi_GetOrganizationEventExecute_Call) Return(_a0 *admin.EventViewForOrg, _a1 *http.Response, _a2 error) *EventsApi_GetOrganizationEventExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *EventsApi_GetOrganizationEventExecute_Call) RunAndReturn(run func(admin.GetOrganizationEventApiRequest) (*admin.EventViewForOrg, *http.Response, error)) *EventsApi_GetOrganizationEventExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationEventWithParams provides a mock function with given fields: ctx, args +func (_m *EventsApi) GetOrganizationEventWithParams(ctx context.Context, args *admin.GetOrganizationEventApiParams) admin.GetOrganizationEventApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationEventWithParams") + } + + var r0 admin.GetOrganizationEventApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOrganizationEventApiParams) admin.GetOrganizationEventApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOrganizationEventApiRequest) + } + + return r0 +} + +// EventsApi_GetOrganizationEventWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationEventWithParams' +type EventsApi_GetOrganizationEventWithParams_Call struct { + *mock.Call +} + +// GetOrganizationEventWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOrganizationEventApiParams +func (_e *EventsApi_Expecter) GetOrganizationEventWithParams(ctx interface{}, args interface{}) *EventsApi_GetOrganizationEventWithParams_Call { + return &EventsApi_GetOrganizationEventWithParams_Call{Call: _e.mock.On("GetOrganizationEventWithParams", ctx, args)} +} + +func (_c *EventsApi_GetOrganizationEventWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOrganizationEventApiParams)) *EventsApi_GetOrganizationEventWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOrganizationEventApiParams)) + }) + return _c +} + +func (_c *EventsApi_GetOrganizationEventWithParams_Call) Return(_a0 admin.GetOrganizationEventApiRequest) *EventsApi_GetOrganizationEventWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_GetOrganizationEventWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOrganizationEventApiParams) admin.GetOrganizationEventApiRequest) *EventsApi_GetOrganizationEventWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectEvent provides a mock function with given fields: ctx, groupId, eventId +func (_m *EventsApi) GetProjectEvent(ctx context.Context, groupId string, eventId string) admin.GetProjectEventApiRequest { + ret := _m.Called(ctx, groupId, eventId) + + if len(ret) == 0 { + panic("no return value specified for GetProjectEvent") + } + + var r0 admin.GetProjectEventApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetProjectEventApiRequest); ok { + r0 = rf(ctx, groupId, eventId) + } else { + r0 = ret.Get(0).(admin.GetProjectEventApiRequest) + } + + return r0 +} + +// EventsApi_GetProjectEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectEvent' +type EventsApi_GetProjectEvent_Call struct { + *mock.Call +} + +// GetProjectEvent is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - eventId string +func (_e *EventsApi_Expecter) GetProjectEvent(ctx interface{}, groupId interface{}, eventId interface{}) *EventsApi_GetProjectEvent_Call { + return &EventsApi_GetProjectEvent_Call{Call: _e.mock.On("GetProjectEvent", ctx, groupId, eventId)} +} + +func (_c *EventsApi_GetProjectEvent_Call) Run(run func(ctx context.Context, groupId string, eventId string)) *EventsApi_GetProjectEvent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *EventsApi_GetProjectEvent_Call) Return(_a0 admin.GetProjectEventApiRequest) *EventsApi_GetProjectEvent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_GetProjectEvent_Call) RunAndReturn(run func(context.Context, string, string) admin.GetProjectEventApiRequest) *EventsApi_GetProjectEvent_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectEventExecute provides a mock function with given fields: r +func (_m *EventsApi) GetProjectEventExecute(r admin.GetProjectEventApiRequest) (*admin.EventViewForNdsGroup, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetProjectEventExecute") + } + + var r0 *admin.EventViewForNdsGroup + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetProjectEventApiRequest) (*admin.EventViewForNdsGroup, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetProjectEventApiRequest) *admin.EventViewForNdsGroup); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.EventViewForNdsGroup) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetProjectEventApiRequest) *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.GetProjectEventApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// EventsApi_GetProjectEventExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectEventExecute' +type EventsApi_GetProjectEventExecute_Call struct { + *mock.Call +} + +// GetProjectEventExecute is a helper method to define mock.On call +// - r admin.GetProjectEventApiRequest +func (_e *EventsApi_Expecter) GetProjectEventExecute(r interface{}) *EventsApi_GetProjectEventExecute_Call { + return &EventsApi_GetProjectEventExecute_Call{Call: _e.mock.On("GetProjectEventExecute", r)} +} + +func (_c *EventsApi_GetProjectEventExecute_Call) Run(run func(r admin.GetProjectEventApiRequest)) *EventsApi_GetProjectEventExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetProjectEventApiRequest)) + }) + return _c +} + +func (_c *EventsApi_GetProjectEventExecute_Call) Return(_a0 *admin.EventViewForNdsGroup, _a1 *http.Response, _a2 error) *EventsApi_GetProjectEventExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *EventsApi_GetProjectEventExecute_Call) RunAndReturn(run func(admin.GetProjectEventApiRequest) (*admin.EventViewForNdsGroup, *http.Response, error)) *EventsApi_GetProjectEventExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectEventWithParams provides a mock function with given fields: ctx, args +func (_m *EventsApi) GetProjectEventWithParams(ctx context.Context, args *admin.GetProjectEventApiParams) admin.GetProjectEventApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetProjectEventWithParams") + } + + var r0 admin.GetProjectEventApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectEventApiParams) admin.GetProjectEventApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetProjectEventApiRequest) + } + + return r0 +} + +// EventsApi_GetProjectEventWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectEventWithParams' +type EventsApi_GetProjectEventWithParams_Call struct { + *mock.Call +} + +// GetProjectEventWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetProjectEventApiParams +func (_e *EventsApi_Expecter) GetProjectEventWithParams(ctx interface{}, args interface{}) *EventsApi_GetProjectEventWithParams_Call { + return &EventsApi_GetProjectEventWithParams_Call{Call: _e.mock.On("GetProjectEventWithParams", ctx, args)} +} + +func (_c *EventsApi_GetProjectEventWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectEventApiParams)) *EventsApi_GetProjectEventWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetProjectEventApiParams)) + }) + return _c +} + +func (_c *EventsApi_GetProjectEventWithParams_Call) Return(_a0 admin.GetProjectEventApiRequest) *EventsApi_GetProjectEventWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_GetProjectEventWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectEventApiParams) admin.GetProjectEventApiRequest) *EventsApi_GetProjectEventWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationEvents provides a mock function with given fields: ctx, orgId +func (_m *EventsApi) ListOrganizationEvents(ctx context.Context, orgId string) admin.ListOrganizationEventsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationEvents") + } + + var r0 admin.ListOrganizationEventsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationEventsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListOrganizationEventsApiRequest) + } + + return r0 +} + +// EventsApi_ListOrganizationEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationEvents' +type EventsApi_ListOrganizationEvents_Call struct { + *mock.Call +} + +// ListOrganizationEvents is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *EventsApi_Expecter) ListOrganizationEvents(ctx interface{}, orgId interface{}) *EventsApi_ListOrganizationEvents_Call { + return &EventsApi_ListOrganizationEvents_Call{Call: _e.mock.On("ListOrganizationEvents", ctx, orgId)} +} + +func (_c *EventsApi_ListOrganizationEvents_Call) Run(run func(ctx context.Context, orgId string)) *EventsApi_ListOrganizationEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *EventsApi_ListOrganizationEvents_Call) Return(_a0 admin.ListOrganizationEventsApiRequest) *EventsApi_ListOrganizationEvents_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_ListOrganizationEvents_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationEventsApiRequest) *EventsApi_ListOrganizationEvents_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationEventsExecute provides a mock function with given fields: r +func (_m *EventsApi) ListOrganizationEventsExecute(r admin.ListOrganizationEventsApiRequest) (*admin.OrgPaginatedEvent, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationEventsExecute") + } + + var r0 *admin.OrgPaginatedEvent + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOrganizationEventsApiRequest) (*admin.OrgPaginatedEvent, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOrganizationEventsApiRequest) *admin.OrgPaginatedEvent); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.OrgPaginatedEvent) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListOrganizationEventsApiRequest) *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.ListOrganizationEventsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// EventsApi_ListOrganizationEventsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationEventsExecute' +type EventsApi_ListOrganizationEventsExecute_Call struct { + *mock.Call +} + +// ListOrganizationEventsExecute is a helper method to define mock.On call +// - r admin.ListOrganizationEventsApiRequest +func (_e *EventsApi_Expecter) ListOrganizationEventsExecute(r interface{}) *EventsApi_ListOrganizationEventsExecute_Call { + return &EventsApi_ListOrganizationEventsExecute_Call{Call: _e.mock.On("ListOrganizationEventsExecute", r)} +} + +func (_c *EventsApi_ListOrganizationEventsExecute_Call) Run(run func(r admin.ListOrganizationEventsApiRequest)) *EventsApi_ListOrganizationEventsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOrganizationEventsApiRequest)) + }) + return _c +} + +func (_c *EventsApi_ListOrganizationEventsExecute_Call) Return(_a0 *admin.OrgPaginatedEvent, _a1 *http.Response, _a2 error) *EventsApi_ListOrganizationEventsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *EventsApi_ListOrganizationEventsExecute_Call) RunAndReturn(run func(admin.ListOrganizationEventsApiRequest) (*admin.OrgPaginatedEvent, *http.Response, error)) *EventsApi_ListOrganizationEventsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationEventsWithParams provides a mock function with given fields: ctx, args +func (_m *EventsApi) ListOrganizationEventsWithParams(ctx context.Context, args *admin.ListOrganizationEventsApiParams) admin.ListOrganizationEventsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationEventsWithParams") + } + + var r0 admin.ListOrganizationEventsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationEventsApiParams) admin.ListOrganizationEventsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOrganizationEventsApiRequest) + } + + return r0 +} + +// EventsApi_ListOrganizationEventsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationEventsWithParams' +type EventsApi_ListOrganizationEventsWithParams_Call struct { + *mock.Call +} + +// ListOrganizationEventsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOrganizationEventsApiParams +func (_e *EventsApi_Expecter) ListOrganizationEventsWithParams(ctx interface{}, args interface{}) *EventsApi_ListOrganizationEventsWithParams_Call { + return &EventsApi_ListOrganizationEventsWithParams_Call{Call: _e.mock.On("ListOrganizationEventsWithParams", ctx, args)} +} + +func (_c *EventsApi_ListOrganizationEventsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationEventsApiParams)) *EventsApi_ListOrganizationEventsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOrganizationEventsApiParams)) + }) + return _c +} + +func (_c *EventsApi_ListOrganizationEventsWithParams_Call) Return(_a0 admin.ListOrganizationEventsApiRequest) *EventsApi_ListOrganizationEventsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_ListOrganizationEventsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationEventsApiParams) admin.ListOrganizationEventsApiRequest) *EventsApi_ListOrganizationEventsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectEvents provides a mock function with given fields: ctx, groupId +func (_m *EventsApi) ListProjectEvents(ctx context.Context, groupId string) admin.ListProjectEventsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListProjectEvents") + } + + var r0 admin.ListProjectEventsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectEventsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListProjectEventsApiRequest) + } + + return r0 +} + +// EventsApi_ListProjectEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectEvents' +type EventsApi_ListProjectEvents_Call struct { + *mock.Call +} + +// ListProjectEvents is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *EventsApi_Expecter) ListProjectEvents(ctx interface{}, groupId interface{}) *EventsApi_ListProjectEvents_Call { + return &EventsApi_ListProjectEvents_Call{Call: _e.mock.On("ListProjectEvents", ctx, groupId)} +} + +func (_c *EventsApi_ListProjectEvents_Call) Run(run func(ctx context.Context, groupId string)) *EventsApi_ListProjectEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *EventsApi_ListProjectEvents_Call) Return(_a0 admin.ListProjectEventsApiRequest) *EventsApi_ListProjectEvents_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_ListProjectEvents_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectEventsApiRequest) *EventsApi_ListProjectEvents_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectEventsExecute provides a mock function with given fields: r +func (_m *EventsApi) ListProjectEventsExecute(r admin.ListProjectEventsApiRequest) (*admin.GroupPaginatedEvent, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListProjectEventsExecute") + } + + var r0 *admin.GroupPaginatedEvent + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListProjectEventsApiRequest) (*admin.GroupPaginatedEvent, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListProjectEventsApiRequest) *admin.GroupPaginatedEvent); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupPaginatedEvent) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListProjectEventsApiRequest) *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.ListProjectEventsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// EventsApi_ListProjectEventsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectEventsExecute' +type EventsApi_ListProjectEventsExecute_Call struct { + *mock.Call +} + +// ListProjectEventsExecute is a helper method to define mock.On call +// - r admin.ListProjectEventsApiRequest +func (_e *EventsApi_Expecter) ListProjectEventsExecute(r interface{}) *EventsApi_ListProjectEventsExecute_Call { + return &EventsApi_ListProjectEventsExecute_Call{Call: _e.mock.On("ListProjectEventsExecute", r)} +} + +func (_c *EventsApi_ListProjectEventsExecute_Call) Run(run func(r admin.ListProjectEventsApiRequest)) *EventsApi_ListProjectEventsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListProjectEventsApiRequest)) + }) + return _c +} + +func (_c *EventsApi_ListProjectEventsExecute_Call) Return(_a0 *admin.GroupPaginatedEvent, _a1 *http.Response, _a2 error) *EventsApi_ListProjectEventsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *EventsApi_ListProjectEventsExecute_Call) RunAndReturn(run func(admin.ListProjectEventsApiRequest) (*admin.GroupPaginatedEvent, *http.Response, error)) *EventsApi_ListProjectEventsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectEventsWithParams provides a mock function with given fields: ctx, args +func (_m *EventsApi) ListProjectEventsWithParams(ctx context.Context, args *admin.ListProjectEventsApiParams) admin.ListProjectEventsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListProjectEventsWithParams") + } + + var r0 admin.ListProjectEventsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectEventsApiParams) admin.ListProjectEventsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListProjectEventsApiRequest) + } + + return r0 +} + +// EventsApi_ListProjectEventsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectEventsWithParams' +type EventsApi_ListProjectEventsWithParams_Call struct { + *mock.Call +} + +// ListProjectEventsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListProjectEventsApiParams +func (_e *EventsApi_Expecter) ListProjectEventsWithParams(ctx interface{}, args interface{}) *EventsApi_ListProjectEventsWithParams_Call { + return &EventsApi_ListProjectEventsWithParams_Call{Call: _e.mock.On("ListProjectEventsWithParams", ctx, args)} +} + +func (_c *EventsApi_ListProjectEventsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectEventsApiParams)) *EventsApi_ListProjectEventsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListProjectEventsApiParams)) + }) + return _c +} + +func (_c *EventsApi_ListProjectEventsWithParams_Call) Return(_a0 admin.ListProjectEventsApiRequest) *EventsApi_ListProjectEventsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *EventsApi_ListProjectEventsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectEventsApiParams) admin.ListProjectEventsApiRequest) *EventsApi_ListProjectEventsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewEventsApi creates a new instance of EventsApi. 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 NewEventsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *EventsApi { + mock := &EventsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/federated_authentication_api.go b/mockadmin/federated_authentication_api.go new file mode 100644 index 000000000..f6834d1ab --- /dev/null +++ b/mockadmin/federated_authentication_api.go @@ -0,0 +1,2921 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// FederatedAuthenticationApi is an autogenerated mock type for the FederatedAuthenticationApi type +type FederatedAuthenticationApi struct { + mock.Mock +} + +type FederatedAuthenticationApi_Expecter struct { + mock *mock.Mock +} + +func (_m *FederatedAuthenticationApi) EXPECT() *FederatedAuthenticationApi_Expecter { + return &FederatedAuthenticationApi_Expecter{mock: &_m.Mock} +} + +// CreateIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, federationOidcIdentityProviderUpdate +func (_m *FederatedAuthenticationApi) CreateIdentityProvider(ctx context.Context, federationSettingsId string, federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest { + ret := _m.Called(ctx, federationSettingsId, federationOidcIdentityProviderUpdate) + + if len(ret) == 0 { + panic("no return value specified for CreateIdentityProvider") + } + + var r0 admin.CreateIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest); ok { + r0 = rf(ctx, federationSettingsId, federationOidcIdentityProviderUpdate) + } else { + r0 = ret.Get(0).(admin.CreateIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_CreateIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIdentityProvider' +type FederatedAuthenticationApi_CreateIdentityProvider_Call struct { + *mock.Call +} + +// CreateIdentityProvider is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate +func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProvider(ctx interface{}, federationSettingsId interface{}, federationOidcIdentityProviderUpdate interface{}) *FederatedAuthenticationApi_CreateIdentityProvider_Call { + return &FederatedAuthenticationApi_CreateIdentityProvider_Call{Call: _e.mock.On("CreateIdentityProvider", ctx, federationSettingsId, federationOidcIdentityProviderUpdate)} +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate)) *FederatedAuthenticationApi_CreateIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.FederationOidcIdentityProviderUpdate)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) Return(_a0 admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) RunAndReturn(run func(context.Context, string, *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// CreateIdentityProviderExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) CreateIdentityProviderExecute(r admin.CreateIdentityProviderApiRequest) (*admin.FederationOidcIdentityProvider, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateIdentityProviderExecute") + } + + var r0 *admin.FederationOidcIdentityProvider + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateIdentityProviderApiRequest) (*admin.FederationOidcIdentityProvider, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateIdentityProviderApiRequest) *admin.FederationOidcIdentityProvider); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.FederationOidcIdentityProvider) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateIdentityProviderApiRequest) *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.CreateIdentityProviderApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_CreateIdentityProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIdentityProviderExecute' +type FederatedAuthenticationApi_CreateIdentityProviderExecute_Call struct { + *mock.Call +} + +// CreateIdentityProviderExecute is a helper method to define mock.On call +// - r admin.CreateIdentityProviderApiRequest +func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call { + return &FederatedAuthenticationApi_CreateIdentityProviderExecute_Call{Call: _e.mock.On("CreateIdentityProviderExecute", r)} +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call) Run(run func(r admin.CreateIdentityProviderApiRequest)) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateIdentityProviderApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call) Return(_a0 *admin.FederationOidcIdentityProvider, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call) RunAndReturn(run func(admin.CreateIdentityProviderApiRequest) (*admin.FederationOidcIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateIdentityProviderWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) CreateIdentityProviderWithParams(ctx context.Context, args *admin.CreateIdentityProviderApiParams) admin.CreateIdentityProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateIdentityProviderWithParams") + } + + var r0 admin.CreateIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateIdentityProviderApiParams) admin.CreateIdentityProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIdentityProviderWithParams' +type FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call struct { + *mock.Call +} + +// CreateIdentityProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateIdentityProviderApiParams +func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call { + return &FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call{Call: _e.mock.On("CreateIdentityProviderWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateIdentityProviderApiParams)) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateIdentityProviderApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call) Return(_a0 admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateIdentityProviderApiParams) admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateRoleMapping provides a mock function with given fields: ctx, federationSettingsId, orgId, authFederationRoleMapping +func (_m *FederatedAuthenticationApi) CreateRoleMapping(ctx context.Context, federationSettingsId string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping) admin.CreateRoleMappingApiRequest { + ret := _m.Called(ctx, federationSettingsId, orgId, authFederationRoleMapping) + + if len(ret) == 0 { + panic("no return value specified for CreateRoleMapping") + } + + var r0 admin.CreateRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.AuthFederationRoleMapping) admin.CreateRoleMappingApiRequest); ok { + r0 = rf(ctx, federationSettingsId, orgId, authFederationRoleMapping) + } else { + r0 = ret.Get(0).(admin.CreateRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_CreateRoleMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoleMapping' +type FederatedAuthenticationApi_CreateRoleMapping_Call struct { + *mock.Call +} + +// CreateRoleMapping is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - orgId string +// - authFederationRoleMapping *admin.AuthFederationRoleMapping +func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMapping(ctx interface{}, federationSettingsId interface{}, orgId interface{}, authFederationRoleMapping interface{}) *FederatedAuthenticationApi_CreateRoleMapping_Call { + return &FederatedAuthenticationApi_CreateRoleMapping_Call{Call: _e.mock.On("CreateRoleMapping", ctx, federationSettingsId, orgId, authFederationRoleMapping)} +} + +func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping)) *FederatedAuthenticationApi_CreateRoleMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.AuthFederationRoleMapping)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) Return(_a0 admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMapping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, *admin.AuthFederationRoleMapping) admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMapping_Call { + _c.Call.Return(run) + return _c +} + +// CreateRoleMappingExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) CreateRoleMappingExecute(r admin.CreateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateRoleMappingExecute") + } + + var r0 *admin.AuthFederationRoleMapping + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateRoleMappingApiRequest) *admin.AuthFederationRoleMapping); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AuthFederationRoleMapping) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateRoleMappingApiRequest) *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.CreateRoleMappingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_CreateRoleMappingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoleMappingExecute' +type FederatedAuthenticationApi_CreateRoleMappingExecute_Call struct { + *mock.Call +} + +// CreateRoleMappingExecute is a helper method to define mock.On call +// - r admin.CreateRoleMappingApiRequest +func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call { + return &FederatedAuthenticationApi_CreateRoleMappingExecute_Call{Call: _e.mock.On("CreateRoleMappingExecute", r)} +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingExecute_Call) Run(run func(r admin.CreateRoleMappingApiRequest)) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateRoleMappingApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingExecute_Call) Return(_a0 *admin.AuthFederationRoleMapping, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingExecute_Call) RunAndReturn(run func(admin.CreateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateRoleMappingWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) CreateRoleMappingWithParams(ctx context.Context, args *admin.CreateRoleMappingApiParams) admin.CreateRoleMappingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateRoleMappingWithParams") + } + + var r0 admin.CreateRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateRoleMappingApiParams) admin.CreateRoleMappingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_CreateRoleMappingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoleMappingWithParams' +type FederatedAuthenticationApi_CreateRoleMappingWithParams_Call struct { + *mock.Call +} + +// CreateRoleMappingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateRoleMappingApiParams +func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call { + return &FederatedAuthenticationApi_CreateRoleMappingWithParams_Call{Call: _e.mock.On("CreateRoleMappingWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateRoleMappingApiParams)) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateRoleMappingApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call) Return(_a0 admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateRoleMappingApiParams) admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederationApp provides a mock function with given fields: ctx, federationSettingsId +func (_m *FederatedAuthenticationApi) DeleteFederationApp(ctx context.Context, federationSettingsId string) admin.DeleteFederationAppApiRequest { + ret := _m.Called(ctx, federationSettingsId) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederationApp") + } + + var r0 admin.DeleteFederationAppApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteFederationAppApiRequest); ok { + r0 = rf(ctx, federationSettingsId) + } else { + r0 = ret.Get(0).(admin.DeleteFederationAppApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteFederationApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederationApp' +type FederatedAuthenticationApi_DeleteFederationApp_Call struct { + *mock.Call +} + +// DeleteFederationApp is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationApp(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_DeleteFederationApp_Call { + return &FederatedAuthenticationApi_DeleteFederationApp_Call{Call: _e.mock.On("DeleteFederationApp", ctx, federationSettingsId)} +} + +func (_c *FederatedAuthenticationApi_DeleteFederationApp_Call) Run(run func(ctx context.Context, federationSettingsId string)) *FederatedAuthenticationApi_DeleteFederationApp_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationApp_Call) Return(_a0 admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationApp_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationApp_Call) RunAndReturn(run func(context.Context, string) admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationApp_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederationAppExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) DeleteFederationAppExecute(r admin.DeleteFederationAppApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederationAppExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeleteFederationAppApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteFederationAppApiRequest) *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.DeleteFederationAppApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// FederatedAuthenticationApi_DeleteFederationAppExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederationAppExecute' +type FederatedAuthenticationApi_DeleteFederationAppExecute_Call struct { + *mock.Call +} + +// DeleteFederationAppExecute is a helper method to define mock.On call +// - r admin.DeleteFederationAppApiRequest +func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationAppExecute(r interface{}) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call { + return &FederatedAuthenticationApi_DeleteFederationAppExecute_Call{Call: _e.mock.On("DeleteFederationAppExecute", r)} +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppExecute_Call) Run(run func(r admin.DeleteFederationAppApiRequest)) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteFederationAppApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppExecute_Call) RunAndReturn(run func(admin.DeleteFederationAppApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteFederationAppWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) DeleteFederationAppWithParams(ctx context.Context, args *admin.DeleteFederationAppApiParams) admin.DeleteFederationAppApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteFederationAppWithParams") + } + + var r0 admin.DeleteFederationAppApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteFederationAppApiParams) admin.DeleteFederationAppApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteFederationAppApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteFederationAppWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFederationAppWithParams' +type FederatedAuthenticationApi_DeleteFederationAppWithParams_Call struct { + *mock.Call +} + +// DeleteFederationAppWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteFederationAppApiParams +func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationAppWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call { + return &FederatedAuthenticationApi_DeleteFederationAppWithParams_Call{Call: _e.mock.On("DeleteFederationAppWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteFederationAppApiParams)) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteFederationAppApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call) Return(_a0 admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteFederationAppApiParams) admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId +func (_m *FederatedAuthenticationApi) DeleteIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.DeleteIdentityProviderApiRequest { + ret := _m.Called(ctx, federationSettingsId, identityProviderId) + + if len(ret) == 0 { + panic("no return value specified for DeleteIdentityProvider") + } + + var r0 admin.DeleteIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteIdentityProviderApiRequest); ok { + r0 = rf(ctx, federationSettingsId, identityProviderId) + } else { + r0 = ret.Get(0).(admin.DeleteIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIdentityProvider' +type FederatedAuthenticationApi_DeleteIdentityProvider_Call struct { + *mock.Call +} + +// DeleteIdentityProvider is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - identityProviderId string +func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_DeleteIdentityProvider_Call { + return &FederatedAuthenticationApi_DeleteIdentityProvider_Call{Call: _e.mock.On("DeleteIdentityProvider", ctx, federationSettingsId, identityProviderId)} +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string)) *FederatedAuthenticationApi_DeleteIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProvider_Call) Return(_a0 admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProvider_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// DeleteIdentityProviderExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) DeleteIdentityProviderExecute(r admin.DeleteIdentityProviderApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteIdentityProviderExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeleteIdentityProviderApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteIdentityProviderApiRequest) *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.DeleteIdentityProviderApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIdentityProviderExecute' +type FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call struct { + *mock.Call +} + +// DeleteIdentityProviderExecute is a helper method to define mock.On call +// - r admin.DeleteIdentityProviderApiRequest +func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call { + return &FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call{Call: _e.mock.On("DeleteIdentityProviderExecute", r)} +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call) Run(run func(r admin.DeleteIdentityProviderApiRequest)) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteIdentityProviderApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call) RunAndReturn(run func(admin.DeleteIdentityProviderApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteIdentityProviderWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) DeleteIdentityProviderWithParams(ctx context.Context, args *admin.DeleteIdentityProviderApiParams) admin.DeleteIdentityProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteIdentityProviderWithParams") + } + + var r0 admin.DeleteIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteIdentityProviderApiParams) admin.DeleteIdentityProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIdentityProviderWithParams' +type FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call struct { + *mock.Call +} + +// DeleteIdentityProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteIdentityProviderApiParams +func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call { + return &FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call{Call: _e.mock.On("DeleteIdentityProviderWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteIdentityProviderApiParams)) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteIdentityProviderApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call) Return(_a0 admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteIdentityProviderApiParams) admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId +func (_m *FederatedAuthenticationApi) DeleteRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string) admin.DeleteRoleMappingApiRequest { + ret := _m.Called(ctx, federationSettingsId, id, orgId) + + if len(ret) == 0 { + panic("no return value specified for DeleteRoleMapping") + } + + var r0 admin.DeleteRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteRoleMappingApiRequest); ok { + r0 = rf(ctx, federationSettingsId, id, orgId) + } else { + r0 = ret.Get(0).(admin.DeleteRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteRoleMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoleMapping' +type FederatedAuthenticationApi_DeleteRoleMapping_Call struct { + *mock.Call +} + +// DeleteRoleMapping is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - id string +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}) *FederatedAuthenticationApi_DeleteRoleMapping_Call { + return &FederatedAuthenticationApi_DeleteRoleMapping_Call{Call: _e.mock.On("DeleteRoleMapping", ctx, federationSettingsId, id, orgId)} +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string)) *FederatedAuthenticationApi_DeleteRoleMapping_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 *FederatedAuthenticationApi_DeleteRoleMapping_Call) Return(_a0 admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMapping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMapping_Call { + _c.Call.Return(run) + return _c +} + +// DeleteRoleMappingExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) DeleteRoleMappingExecute(r admin.DeleteRoleMappingApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteRoleMappingExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeleteRoleMappingApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteRoleMappingApiRequest) *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.DeleteRoleMappingApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// FederatedAuthenticationApi_DeleteRoleMappingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoleMappingExecute' +type FederatedAuthenticationApi_DeleteRoleMappingExecute_Call struct { + *mock.Call +} + +// DeleteRoleMappingExecute is a helper method to define mock.On call +// - r admin.DeleteRoleMappingApiRequest +func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call { + return &FederatedAuthenticationApi_DeleteRoleMappingExecute_Call{Call: _e.mock.On("DeleteRoleMappingExecute", r)} +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call) Run(run func(r admin.DeleteRoleMappingApiRequest)) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteRoleMappingApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call) RunAndReturn(run func(admin.DeleteRoleMappingApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteRoleMappingWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) DeleteRoleMappingWithParams(ctx context.Context, args *admin.DeleteRoleMappingApiParams) admin.DeleteRoleMappingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteRoleMappingWithParams") + } + + var r0 admin.DeleteRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteRoleMappingApiParams) admin.DeleteRoleMappingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoleMappingWithParams' +type FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call struct { + *mock.Call +} + +// DeleteRoleMappingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteRoleMappingApiParams +func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call { + return &FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call{Call: _e.mock.On("DeleteRoleMappingWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteRoleMappingApiParams)) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteRoleMappingApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call) Return(_a0 admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteRoleMappingApiParams) admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId +func (_m *FederatedAuthenticationApi) GetConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string) admin.GetConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, federationSettingsId, orgId) + + if len(ret) == 0 { + panic("no return value specified for GetConnectedOrgConfig") + } + + var r0 admin.GetConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, federationSettingsId, orgId) + } else { + r0 = ret.Get(0).(admin.GetConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetConnectedOrgConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnectedOrgConfig' +type FederatedAuthenticationApi_GetConnectedOrgConfig_Call struct { + *mock.Call +} + +// GetConnectedOrgConfig is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) GetConnectedOrgConfig(ctx interface{}, federationSettingsId interface{}, orgId interface{}) *FederatedAuthenticationApi_GetConnectedOrgConfig_Call { + return &FederatedAuthenticationApi_GetConnectedOrgConfig_Call{Call: _e.mock.On("GetConnectedOrgConfig", ctx, federationSettingsId, orgId)} +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfig_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string)) *FederatedAuthenticationApi_GetConnectedOrgConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfig_Call) Return(_a0 admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfig_Call) RunAndReturn(run func(context.Context, string, string) admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetConnectedOrgConfigExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) GetConnectedOrgConfigExecute(r admin.GetConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetConnectedOrgConfigExecute") + } + + var r0 *admin.ConnectedOrgConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetConnectedOrgConfigApiRequest) *admin.ConnectedOrgConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ConnectedOrgConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetConnectedOrgConfigApiRequest) *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.GetConnectedOrgConfigApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnectedOrgConfigExecute' +type FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call struct { + *mock.Call +} + +// GetConnectedOrgConfigExecute is a helper method to define mock.On call +// - r admin.GetConnectedOrgConfigApiRequest +func (_e *FederatedAuthenticationApi_Expecter) GetConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call { + return &FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call{Call: _e.mock.On("GetConnectedOrgConfigExecute", r)} +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call) Run(run func(r admin.GetConnectedOrgConfigApiRequest)) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetConnectedOrgConfigApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call) Return(_a0 *admin.ConnectedOrgConfig, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call) RunAndReturn(run func(admin.GetConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) GetConnectedOrgConfigWithParams(ctx context.Context, args *admin.GetConnectedOrgConfigApiParams) admin.GetConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetConnectedOrgConfigWithParams") + } + + var r0 admin.GetConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetConnectedOrgConfigApiParams) admin.GetConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnectedOrgConfigWithParams' +type FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call struct { + *mock.Call +} + +// GetConnectedOrgConfigWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetConnectedOrgConfigApiParams +func (_e *FederatedAuthenticationApi_Expecter) GetConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call { + return &FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call{Call: _e.mock.On("GetConnectedOrgConfigWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call) Run(run func(ctx context.Context, args *admin.GetConnectedOrgConfigApiParams)) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetConnectedOrgConfigApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call) Return(_a0 admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetConnectedOrgConfigApiParams) admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetFederationSettings provides a mock function with given fields: ctx, orgId +func (_m *FederatedAuthenticationApi) GetFederationSettings(ctx context.Context, orgId string) admin.GetFederationSettingsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for GetFederationSettings") + } + + var r0 admin.GetFederationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetFederationSettingsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.GetFederationSettingsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetFederationSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederationSettings' +type FederatedAuthenticationApi_GetFederationSettings_Call struct { + *mock.Call +} + +// GetFederationSettings is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) GetFederationSettings(ctx interface{}, orgId interface{}) *FederatedAuthenticationApi_GetFederationSettings_Call { + return &FederatedAuthenticationApi_GetFederationSettings_Call{Call: _e.mock.On("GetFederationSettings", ctx, orgId)} +} + +func (_c *FederatedAuthenticationApi_GetFederationSettings_Call) Run(run func(ctx context.Context, orgId string)) *FederatedAuthenticationApi_GetFederationSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettings_Call) Return(_a0 admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettings_Call) RunAndReturn(run func(context.Context, string) admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettings_Call { + _c.Call.Return(run) + return _c +} + +// GetFederationSettingsExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) GetFederationSettingsExecute(r admin.GetFederationSettingsApiRequest) (*admin.OrgFederationSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetFederationSettingsExecute") + } + + var r0 *admin.OrgFederationSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetFederationSettingsApiRequest) (*admin.OrgFederationSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetFederationSettingsApiRequest) *admin.OrgFederationSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.OrgFederationSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetFederationSettingsApiRequest) *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.GetFederationSettingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_GetFederationSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederationSettingsExecute' +type FederatedAuthenticationApi_GetFederationSettingsExecute_Call struct { + *mock.Call +} + +// GetFederationSettingsExecute is a helper method to define mock.On call +// - r admin.GetFederationSettingsApiRequest +func (_e *FederatedAuthenticationApi_Expecter) GetFederationSettingsExecute(r interface{}) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call { + return &FederatedAuthenticationApi_GetFederationSettingsExecute_Call{Call: _e.mock.On("GetFederationSettingsExecute", r)} +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsExecute_Call) Run(run func(r admin.GetFederationSettingsApiRequest)) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetFederationSettingsApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsExecute_Call) Return(_a0 *admin.OrgFederationSettings, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsExecute_Call) RunAndReturn(run func(admin.GetFederationSettingsApiRequest) (*admin.OrgFederationSettings, *http.Response, error)) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetFederationSettingsWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) GetFederationSettingsWithParams(ctx context.Context, args *admin.GetFederationSettingsApiParams) admin.GetFederationSettingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetFederationSettingsWithParams") + } + + var r0 admin.GetFederationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetFederationSettingsApiParams) admin.GetFederationSettingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetFederationSettingsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetFederationSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFederationSettingsWithParams' +type FederatedAuthenticationApi_GetFederationSettingsWithParams_Call struct { + *mock.Call +} + +// GetFederationSettingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetFederationSettingsApiParams +func (_e *FederatedAuthenticationApi_Expecter) GetFederationSettingsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call { + return &FederatedAuthenticationApi_GetFederationSettingsWithParams_Call{Call: _e.mock.On("GetFederationSettingsWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetFederationSettingsApiParams)) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetFederationSettingsApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call) Return(_a0 admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetFederationSettingsApiParams) admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId +func (_m *FederatedAuthenticationApi) GetIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.GetIdentityProviderApiRequest { + ret := _m.Called(ctx, federationSettingsId, identityProviderId) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProvider") + } + + var r0 admin.GetIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetIdentityProviderApiRequest); ok { + r0 = rf(ctx, federationSettingsId, identityProviderId) + } else { + r0 = ret.Get(0).(admin.GetIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProvider' +type FederatedAuthenticationApi_GetIdentityProvider_Call struct { + *mock.Call +} + +// GetIdentityProvider is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - identityProviderId string +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_GetIdentityProvider_Call { + return &FederatedAuthenticationApi_GetIdentityProvider_Call{Call: _e.mock.On("GetIdentityProvider", ctx, federationSettingsId, identityProviderId)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string)) *FederatedAuthenticationApi_GetIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProvider_Call) Return(_a0 admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProvider_Call) RunAndReturn(run func(context.Context, string, string) admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProviderExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) GetIdentityProviderExecute(r admin.GetIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProviderExecute") + } + + var r0 *admin.FederationIdentityProvider + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetIdentityProviderApiRequest) *admin.FederationIdentityProvider); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.FederationIdentityProvider) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetIdentityProviderApiRequest) *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.GetIdentityProviderApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_GetIdentityProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProviderExecute' +type FederatedAuthenticationApi_GetIdentityProviderExecute_Call struct { + *mock.Call +} + +// GetIdentityProviderExecute is a helper method to define mock.On call +// - r admin.GetIdentityProviderApiRequest +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call { + return &FederatedAuthenticationApi_GetIdentityProviderExecute_Call{Call: _e.mock.On("GetIdentityProviderExecute", r)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderExecute_Call) Run(run func(r admin.GetIdentityProviderApiRequest)) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetIdentityProviderApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderExecute_Call) Return(_a0 *admin.FederationIdentityProvider, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderExecute_Call) RunAndReturn(run func(admin.GetIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProviderMetadata provides a mock function with given fields: ctx, federationSettingsId, identityProviderId +func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadata(ctx context.Context, federationSettingsId string, identityProviderId string) admin.GetIdentityProviderMetadataApiRequest { + ret := _m.Called(ctx, federationSettingsId, identityProviderId) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProviderMetadata") + } + + var r0 admin.GetIdentityProviderMetadataApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetIdentityProviderMetadataApiRequest); ok { + r0 = rf(ctx, federationSettingsId, identityProviderId) + } else { + r0 = ret.Get(0).(admin.GetIdentityProviderMetadataApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetIdentityProviderMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProviderMetadata' +type FederatedAuthenticationApi_GetIdentityProviderMetadata_Call struct { + *mock.Call +} + +// GetIdentityProviderMetadata is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - identityProviderId string +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadata(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call { + return &FederatedAuthenticationApi_GetIdentityProviderMetadata_Call{Call: _e.mock.On("GetIdentityProviderMetadata", ctx, federationSettingsId, identityProviderId)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string)) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call) Return(_a0 admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call) RunAndReturn(run func(context.Context, string, string) admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProviderMetadataExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadataExecute(r admin.GetIdentityProviderMetadataApiRequest) (string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProviderMetadataExecute") + } + + var r0 string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetIdentityProviderMetadataApiRequest) (string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetIdentityProviderMetadataApiRequest) string); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(admin.GetIdentityProviderMetadataApiRequest) *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.GetIdentityProviderMetadataApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProviderMetadataExecute' +type FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call struct { + *mock.Call +} + +// GetIdentityProviderMetadataExecute is a helper method to define mock.On call +// - r admin.GetIdentityProviderMetadataApiRequest +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadataExecute(r interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call { + return &FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call{Call: _e.mock.On("GetIdentityProviderMetadataExecute", r)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call) Run(run func(r admin.GetIdentityProviderMetadataApiRequest)) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetIdentityProviderMetadataApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call) RunAndReturn(run func(admin.GetIdentityProviderMetadataApiRequest) (string, *http.Response, error)) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProviderMetadataWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadataWithParams(ctx context.Context, args *admin.GetIdentityProviderMetadataApiParams) admin.GetIdentityProviderMetadataApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProviderMetadataWithParams") + } + + var r0 admin.GetIdentityProviderMetadataApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetIdentityProviderMetadataApiParams) admin.GetIdentityProviderMetadataApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetIdentityProviderMetadataApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProviderMetadataWithParams' +type FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call struct { + *mock.Call +} + +// GetIdentityProviderMetadataWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetIdentityProviderMetadataApiParams +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadataWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call { + return &FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call{Call: _e.mock.On("GetIdentityProviderMetadataWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call) Run(run func(ctx context.Context, args *admin.GetIdentityProviderMetadataApiParams)) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetIdentityProviderMetadataApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call) Return(_a0 admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetIdentityProviderMetadataApiParams) admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentityProviderWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) GetIdentityProviderWithParams(ctx context.Context, args *admin.GetIdentityProviderApiParams) admin.GetIdentityProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetIdentityProviderWithParams") + } + + var r0 admin.GetIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetIdentityProviderApiParams) admin.GetIdentityProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetIdentityProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentityProviderWithParams' +type FederatedAuthenticationApi_GetIdentityProviderWithParams_Call struct { + *mock.Call +} + +// GetIdentityProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetIdentityProviderApiParams +func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call { + return &FederatedAuthenticationApi_GetIdentityProviderWithParams_Call{Call: _e.mock.On("GetIdentityProviderWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.GetIdentityProviderApiParams)) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetIdentityProviderApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call) Return(_a0 admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetIdentityProviderApiParams) admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId +func (_m *FederatedAuthenticationApi) GetRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string) admin.GetRoleMappingApiRequest { + ret := _m.Called(ctx, federationSettingsId, id, orgId) + + if len(ret) == 0 { + panic("no return value specified for GetRoleMapping") + } + + var r0 admin.GetRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetRoleMappingApiRequest); ok { + r0 = rf(ctx, federationSettingsId, id, orgId) + } else { + r0 = ret.Get(0).(admin.GetRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetRoleMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoleMapping' +type FederatedAuthenticationApi_GetRoleMapping_Call struct { + *mock.Call +} + +// GetRoleMapping is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - id string +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) GetRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}) *FederatedAuthenticationApi_GetRoleMapping_Call { + return &FederatedAuthenticationApi_GetRoleMapping_Call{Call: _e.mock.On("GetRoleMapping", ctx, federationSettingsId, id, orgId)} +} + +func (_c *FederatedAuthenticationApi_GetRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string)) *FederatedAuthenticationApi_GetRoleMapping_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 *FederatedAuthenticationApi_GetRoleMapping_Call) Return(_a0 admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMapping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMapping_Call { + _c.Call.Return(run) + return _c +} + +// GetRoleMappingExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) GetRoleMappingExecute(r admin.GetRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetRoleMappingExecute") + } + + var r0 *admin.AuthFederationRoleMapping + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetRoleMappingApiRequest) *admin.AuthFederationRoleMapping); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AuthFederationRoleMapping) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetRoleMappingApiRequest) *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.GetRoleMappingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_GetRoleMappingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoleMappingExecute' +type FederatedAuthenticationApi_GetRoleMappingExecute_Call struct { + *mock.Call +} + +// GetRoleMappingExecute is a helper method to define mock.On call +// - r admin.GetRoleMappingApiRequest +func (_e *FederatedAuthenticationApi_Expecter) GetRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_GetRoleMappingExecute_Call { + return &FederatedAuthenticationApi_GetRoleMappingExecute_Call{Call: _e.mock.On("GetRoleMappingExecute", r)} +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingExecute_Call) Run(run func(r admin.GetRoleMappingApiRequest)) *FederatedAuthenticationApi_GetRoleMappingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetRoleMappingApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingExecute_Call) Return(_a0 *admin.AuthFederationRoleMapping, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetRoleMappingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingExecute_Call) RunAndReturn(run func(admin.GetRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_GetRoleMappingExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetRoleMappingWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) GetRoleMappingWithParams(ctx context.Context, args *admin.GetRoleMappingApiParams) admin.GetRoleMappingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetRoleMappingWithParams") + } + + var r0 admin.GetRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetRoleMappingApiParams) admin.GetRoleMappingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_GetRoleMappingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoleMappingWithParams' +type FederatedAuthenticationApi_GetRoleMappingWithParams_Call struct { + *mock.Call +} + +// GetRoleMappingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetRoleMappingApiParams +func (_e *FederatedAuthenticationApi_Expecter) GetRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call { + return &FederatedAuthenticationApi_GetRoleMappingWithParams_Call{Call: _e.mock.On("GetRoleMappingWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingWithParams_Call) Run(run func(ctx context.Context, args *admin.GetRoleMappingApiParams)) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetRoleMappingApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingWithParams_Call) Return(_a0 admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_GetRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetRoleMappingApiParams) admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListConnectedOrgConfigs provides a mock function with given fields: ctx, federationSettingsId +func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigs(ctx context.Context, federationSettingsId string) admin.ListConnectedOrgConfigsApiRequest { + ret := _m.Called(ctx, federationSettingsId) + + if len(ret) == 0 { + panic("no return value specified for ListConnectedOrgConfigs") + } + + var r0 admin.ListConnectedOrgConfigsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListConnectedOrgConfigsApiRequest); ok { + r0 = rf(ctx, federationSettingsId) + } else { + r0 = ret.Get(0).(admin.ListConnectedOrgConfigsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListConnectedOrgConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnectedOrgConfigs' +type FederatedAuthenticationApi_ListConnectedOrgConfigs_Call struct { + *mock.Call +} + +// ListConnectedOrgConfigs is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigs(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call { + return &FederatedAuthenticationApi_ListConnectedOrgConfigs_Call{Call: _e.mock.On("ListConnectedOrgConfigs", ctx, federationSettingsId)} +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call) Run(run func(ctx context.Context, federationSettingsId string)) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call) Return(_a0 admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call) RunAndReturn(run func(context.Context, string) admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call { + _c.Call.Return(run) + return _c +} + +// ListConnectedOrgConfigsExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigsExecute(r admin.ListConnectedOrgConfigsApiRequest) ([]admin.ConnectedOrgConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListConnectedOrgConfigsExecute") + } + + var r0 []admin.ConnectedOrgConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListConnectedOrgConfigsApiRequest) ([]admin.ConnectedOrgConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListConnectedOrgConfigsApiRequest) []admin.ConnectedOrgConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.ConnectedOrgConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListConnectedOrgConfigsApiRequest) *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.ListConnectedOrgConfigsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnectedOrgConfigsExecute' +type FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call struct { + *mock.Call +} + +// ListConnectedOrgConfigsExecute is a helper method to define mock.On call +// - r admin.ListConnectedOrgConfigsApiRequest +func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigsExecute(r interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call { + return &FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call{Call: _e.mock.On("ListConnectedOrgConfigsExecute", r)} +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call) Run(run func(r admin.ListConnectedOrgConfigsApiRequest)) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListConnectedOrgConfigsApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call) Return(_a0 []admin.ConnectedOrgConfig, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call) RunAndReturn(run func(admin.ListConnectedOrgConfigsApiRequest) ([]admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListConnectedOrgConfigsWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigsWithParams(ctx context.Context, args *admin.ListConnectedOrgConfigsApiParams) admin.ListConnectedOrgConfigsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListConnectedOrgConfigsWithParams") + } + + var r0 admin.ListConnectedOrgConfigsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListConnectedOrgConfigsApiParams) admin.ListConnectedOrgConfigsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListConnectedOrgConfigsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnectedOrgConfigsWithParams' +type FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call struct { + *mock.Call +} + +// ListConnectedOrgConfigsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListConnectedOrgConfigsApiParams +func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call { + return &FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call{Call: _e.mock.On("ListConnectedOrgConfigsWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListConnectedOrgConfigsApiParams)) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListConnectedOrgConfigsApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call) Return(_a0 admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListConnectedOrgConfigsApiParams) admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListIdentityProviders provides a mock function with given fields: ctx, federationSettingsId +func (_m *FederatedAuthenticationApi) ListIdentityProviders(ctx context.Context, federationSettingsId string) admin.ListIdentityProvidersApiRequest { + ret := _m.Called(ctx, federationSettingsId) + + if len(ret) == 0 { + panic("no return value specified for ListIdentityProviders") + } + + var r0 admin.ListIdentityProvidersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListIdentityProvidersApiRequest); ok { + r0 = rf(ctx, federationSettingsId) + } else { + r0 = ret.Get(0).(admin.ListIdentityProvidersApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListIdentityProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIdentityProviders' +type FederatedAuthenticationApi_ListIdentityProviders_Call struct { + *mock.Call +} + +// ListIdentityProviders is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProviders(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_ListIdentityProviders_Call { + return &FederatedAuthenticationApi_ListIdentityProviders_Call{Call: _e.mock.On("ListIdentityProviders", ctx, federationSettingsId)} +} + +func (_c *FederatedAuthenticationApi_ListIdentityProviders_Call) Run(run func(ctx context.Context, federationSettingsId string)) *FederatedAuthenticationApi_ListIdentityProviders_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProviders_Call) Return(_a0 admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProviders_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProviders_Call) RunAndReturn(run func(context.Context, string) admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProviders_Call { + _c.Call.Return(run) + return _c +} + +// ListIdentityProvidersExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) ListIdentityProvidersExecute(r admin.ListIdentityProvidersApiRequest) (*admin.PaginatedFederationIdentityProvider, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListIdentityProvidersExecute") + } + + var r0 *admin.PaginatedFederationIdentityProvider + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListIdentityProvidersApiRequest) (*admin.PaginatedFederationIdentityProvider, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListIdentityProvidersApiRequest) *admin.PaginatedFederationIdentityProvider); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedFederationIdentityProvider) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListIdentityProvidersApiRequest) *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.ListIdentityProvidersApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_ListIdentityProvidersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIdentityProvidersExecute' +type FederatedAuthenticationApi_ListIdentityProvidersExecute_Call struct { + *mock.Call +} + +// ListIdentityProvidersExecute is a helper method to define mock.On call +// - r admin.ListIdentityProvidersApiRequest +func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProvidersExecute(r interface{}) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call { + return &FederatedAuthenticationApi_ListIdentityProvidersExecute_Call{Call: _e.mock.On("ListIdentityProvidersExecute", r)} +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call) Run(run func(r admin.ListIdentityProvidersApiRequest)) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListIdentityProvidersApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call) Return(_a0 *admin.PaginatedFederationIdentityProvider, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call) RunAndReturn(run func(admin.ListIdentityProvidersApiRequest) (*admin.PaginatedFederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListIdentityProvidersWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) ListIdentityProvidersWithParams(ctx context.Context, args *admin.ListIdentityProvidersApiParams) admin.ListIdentityProvidersApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListIdentityProvidersWithParams") + } + + var r0 admin.ListIdentityProvidersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListIdentityProvidersApiParams) admin.ListIdentityProvidersApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListIdentityProvidersApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIdentityProvidersWithParams' +type FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call struct { + *mock.Call +} + +// ListIdentityProvidersWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListIdentityProvidersApiParams +func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProvidersWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call { + return &FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call{Call: _e.mock.On("ListIdentityProvidersWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListIdentityProvidersApiParams)) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListIdentityProvidersApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call) Return(_a0 admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListIdentityProvidersApiParams) admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListRoleMappings provides a mock function with given fields: ctx, federationSettingsId, orgId +func (_m *FederatedAuthenticationApi) ListRoleMappings(ctx context.Context, federationSettingsId string, orgId string) admin.ListRoleMappingsApiRequest { + ret := _m.Called(ctx, federationSettingsId, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListRoleMappings") + } + + var r0 admin.ListRoleMappingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListRoleMappingsApiRequest); ok { + r0 = rf(ctx, federationSettingsId, orgId) + } else { + r0 = ret.Get(0).(admin.ListRoleMappingsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListRoleMappings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoleMappings' +type FederatedAuthenticationApi_ListRoleMappings_Call struct { + *mock.Call +} + +// ListRoleMappings is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) ListRoleMappings(ctx interface{}, federationSettingsId interface{}, orgId interface{}) *FederatedAuthenticationApi_ListRoleMappings_Call { + return &FederatedAuthenticationApi_ListRoleMappings_Call{Call: _e.mock.On("ListRoleMappings", ctx, federationSettingsId, orgId)} +} + +func (_c *FederatedAuthenticationApi_ListRoleMappings_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string)) *FederatedAuthenticationApi_ListRoleMappings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappings_Call) Return(_a0 admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappings_Call) RunAndReturn(run func(context.Context, string, string) admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappings_Call { + _c.Call.Return(run) + return _c +} + +// ListRoleMappingsExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) ListRoleMappingsExecute(r admin.ListRoleMappingsApiRequest) (*admin.PaginatedRoleMapping, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListRoleMappingsExecute") + } + + var r0 *admin.PaginatedRoleMapping + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListRoleMappingsApiRequest) (*admin.PaginatedRoleMapping, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListRoleMappingsApiRequest) *admin.PaginatedRoleMapping); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedRoleMapping) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListRoleMappingsApiRequest) *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.ListRoleMappingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_ListRoleMappingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoleMappingsExecute' +type FederatedAuthenticationApi_ListRoleMappingsExecute_Call struct { + *mock.Call +} + +// ListRoleMappingsExecute is a helper method to define mock.On call +// - r admin.ListRoleMappingsApiRequest +func (_e *FederatedAuthenticationApi_Expecter) ListRoleMappingsExecute(r interface{}) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call { + return &FederatedAuthenticationApi_ListRoleMappingsExecute_Call{Call: _e.mock.On("ListRoleMappingsExecute", r)} +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsExecute_Call) Run(run func(r admin.ListRoleMappingsApiRequest)) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListRoleMappingsApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsExecute_Call) Return(_a0 *admin.PaginatedRoleMapping, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsExecute_Call) RunAndReturn(run func(admin.ListRoleMappingsApiRequest) (*admin.PaginatedRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListRoleMappingsWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) ListRoleMappingsWithParams(ctx context.Context, args *admin.ListRoleMappingsApiParams) admin.ListRoleMappingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListRoleMappingsWithParams") + } + + var r0 admin.ListRoleMappingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListRoleMappingsApiParams) admin.ListRoleMappingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListRoleMappingsApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_ListRoleMappingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoleMappingsWithParams' +type FederatedAuthenticationApi_ListRoleMappingsWithParams_Call struct { + *mock.Call +} + +// ListRoleMappingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListRoleMappingsApiParams +func (_e *FederatedAuthenticationApi_Expecter) ListRoleMappingsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call { + return &FederatedAuthenticationApi_ListRoleMappingsWithParams_Call{Call: _e.mock.On("ListRoleMappingsWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListRoleMappingsApiParams)) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListRoleMappingsApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call) Return(_a0 admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListRoleMappingsApiParams) admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// RemoveConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId +func (_m *FederatedAuthenticationApi) RemoveConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string) admin.RemoveConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, federationSettingsId, orgId) + + if len(ret) == 0 { + panic("no return value specified for RemoveConnectedOrgConfig") + } + + var r0 admin.RemoveConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, federationSettingsId, orgId) + } else { + r0 = ret.Get(0).(admin.RemoveConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveConnectedOrgConfig' +type FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call struct { + *mock.Call +} + +// RemoveConnectedOrgConfig is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - orgId string +func (_e *FederatedAuthenticationApi_Expecter) RemoveConnectedOrgConfig(ctx interface{}, federationSettingsId interface{}, orgId interface{}) *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call { + return &FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call{Call: _e.mock.On("RemoveConnectedOrgConfig", ctx, federationSettingsId, orgId)} +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string)) *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call) Return(_a0 admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call { + _c.Call.Return(run) + return _c +} + +// RemoveConnectedOrgConfigExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) RemoveConnectedOrgConfigExecute(r admin.RemoveConnectedOrgConfigApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for RemoveConnectedOrgConfigExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.RemoveConnectedOrgConfigApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.RemoveConnectedOrgConfigApiRequest) 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.RemoveConnectedOrgConfigApiRequest) *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.RemoveConnectedOrgConfigApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveConnectedOrgConfigExecute' +type FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call struct { + *mock.Call +} + +// RemoveConnectedOrgConfigExecute is a helper method to define mock.On call +// - r admin.RemoveConnectedOrgConfigApiRequest +func (_e *FederatedAuthenticationApi_Expecter) RemoveConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call { + return &FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call{Call: _e.mock.On("RemoveConnectedOrgConfigExecute", r)} +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call) Run(run func(r admin.RemoveConnectedOrgConfigApiRequest)) *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.RemoveConnectedOrgConfigApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call) RunAndReturn(run func(admin.RemoveConnectedOrgConfigApiRequest) (map[string]interface{}, *http.Response, error)) *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call { + _c.Call.Return(run) + return _c +} + +// RemoveConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) RemoveConnectedOrgConfigWithParams(ctx context.Context, args *admin.RemoveConnectedOrgConfigApiParams) admin.RemoveConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for RemoveConnectedOrgConfigWithParams") + } + + var r0 admin.RemoveConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveConnectedOrgConfigApiParams) admin.RemoveConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.RemoveConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveConnectedOrgConfigWithParams' +type FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call struct { + *mock.Call +} + +// RemoveConnectedOrgConfigWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.RemoveConnectedOrgConfigApiParams +func (_e *FederatedAuthenticationApi_Expecter) RemoveConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call { + return &FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call{Call: _e.mock.On("RemoveConnectedOrgConfigWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveConnectedOrgConfigApiParams)) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.RemoveConnectedOrgConfigApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call) Return(_a0 admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveConnectedOrgConfigApiParams) admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call { + _c.Call.Return(run) + return _c +} + +// RevokeJwksFromIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId +func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.RevokeJwksFromIdentityProviderApiRequest { + ret := _m.Called(ctx, federationSettingsId, identityProviderId) + + if len(ret) == 0 { + panic("no return value specified for RevokeJwksFromIdentityProvider") + } + + var r0 admin.RevokeJwksFromIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RevokeJwksFromIdentityProviderApiRequest); ok { + r0 = rf(ctx, federationSettingsId, identityProviderId) + } else { + r0 = ret.Get(0).(admin.RevokeJwksFromIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeJwksFromIdentityProvider' +type FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call struct { + *mock.Call +} + +// RevokeJwksFromIdentityProvider is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - identityProviderId string +func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call { + return &FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call{Call: _e.mock.On("RevokeJwksFromIdentityProvider", ctx, federationSettingsId, identityProviderId)} +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string)) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call) Return(_a0 admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call) RunAndReturn(run func(context.Context, string, string) admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// RevokeJwksFromIdentityProviderExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProviderExecute(r admin.RevokeJwksFromIdentityProviderApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for RevokeJwksFromIdentityProviderExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.RevokeJwksFromIdentityProviderApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.RevokeJwksFromIdentityProviderApiRequest) *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.RevokeJwksFromIdentityProviderApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeJwksFromIdentityProviderExecute' +type FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call struct { + *mock.Call +} + +// RevokeJwksFromIdentityProviderExecute is a helper method to define mock.On call +// - r admin.RevokeJwksFromIdentityProviderApiRequest +func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call { + return &FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call{Call: _e.mock.On("RevokeJwksFromIdentityProviderExecute", r)} +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call) Run(run func(r admin.RevokeJwksFromIdentityProviderApiRequest)) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.RevokeJwksFromIdentityProviderApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call) RunAndReturn(run func(admin.RevokeJwksFromIdentityProviderApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// RevokeJwksFromIdentityProviderWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProviderWithParams(ctx context.Context, args *admin.RevokeJwksFromIdentityProviderApiParams) admin.RevokeJwksFromIdentityProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for RevokeJwksFromIdentityProviderWithParams") + } + + var r0 admin.RevokeJwksFromIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.RevokeJwksFromIdentityProviderApiParams) admin.RevokeJwksFromIdentityProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.RevokeJwksFromIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeJwksFromIdentityProviderWithParams' +type FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call struct { + *mock.Call +} + +// RevokeJwksFromIdentityProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.RevokeJwksFromIdentityProviderApiParams +func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call { + return &FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call{Call: _e.mock.On("RevokeJwksFromIdentityProviderWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.RevokeJwksFromIdentityProviderApiParams)) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.RevokeJwksFromIdentityProviderApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call) Return(_a0 admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.RevokeJwksFromIdentityProviderApiParams) admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId, connectedOrgConfig +func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string, connectedOrgConfig *admin.ConnectedOrgConfig) admin.UpdateConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, federationSettingsId, orgId, connectedOrgConfig) + + if len(ret) == 0 { + panic("no return value specified for UpdateConnectedOrgConfig") + } + + var r0 admin.UpdateConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ConnectedOrgConfig) admin.UpdateConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, federationSettingsId, orgId, connectedOrgConfig) + } else { + r0 = ret.Get(0).(admin.UpdateConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConnectedOrgConfig' +type FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call struct { + *mock.Call +} + +// UpdateConnectedOrgConfig is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - orgId string +// - connectedOrgConfig *admin.ConnectedOrgConfig +func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfig(ctx interface{}, federationSettingsId interface{}, orgId interface{}, connectedOrgConfig interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call { + return &FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call{Call: _e.mock.On("UpdateConnectedOrgConfig", ctx, federationSettingsId, orgId, connectedOrgConfig)} +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string, connectedOrgConfig *admin.ConnectedOrgConfig)) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ConnectedOrgConfig)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) Return(_a0 admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) RunAndReturn(run func(context.Context, string, string, *admin.ConnectedOrgConfig) admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call { + _c.Call.Return(run) + return _c +} + +// UpdateConnectedOrgConfigExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfigExecute(r admin.UpdateConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateConnectedOrgConfigExecute") + } + + var r0 *admin.ConnectedOrgConfig + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateConnectedOrgConfigApiRequest) *admin.ConnectedOrgConfig); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ConnectedOrgConfig) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateConnectedOrgConfigApiRequest) *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.UpdateConnectedOrgConfigApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConnectedOrgConfigExecute' +type FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call struct { + *mock.Call +} + +// UpdateConnectedOrgConfigExecute is a helper method to define mock.On call +// - r admin.UpdateConnectedOrgConfigApiRequest +func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call { + return &FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call{Call: _e.mock.On("UpdateConnectedOrgConfigExecute", r)} +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call) Run(run func(r admin.UpdateConnectedOrgConfigApiRequest)) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateConnectedOrgConfigApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call) Return(_a0 *admin.ConnectedOrgConfig, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call) RunAndReturn(run func(admin.UpdateConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfigWithParams(ctx context.Context, args *admin.UpdateConnectedOrgConfigApiParams) admin.UpdateConnectedOrgConfigApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateConnectedOrgConfigWithParams") + } + + var r0 admin.UpdateConnectedOrgConfigApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateConnectedOrgConfigApiParams) admin.UpdateConnectedOrgConfigApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateConnectedOrgConfigApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConnectedOrgConfigWithParams' +type FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call struct { + *mock.Call +} + +// UpdateConnectedOrgConfigWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateConnectedOrgConfigApiParams +func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call { + return &FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call{Call: _e.mock.On("UpdateConnectedOrgConfigWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateConnectedOrgConfigApiParams)) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateConnectedOrgConfigApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call) Return(_a0 admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateConnectedOrgConfigApiParams) admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate +func (_m *FederatedAuthenticationApi) UpdateIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string, federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest { + ret := _m.Called(ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate) + + if len(ret) == 0 { + panic("no return value specified for UpdateIdentityProvider") + } + + var r0 admin.UpdateIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest); ok { + r0 = rf(ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate) + } else { + r0 = ret.Get(0).(admin.UpdateIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateIdentityProvider' +type FederatedAuthenticationApi_UpdateIdentityProvider_Call struct { + *mock.Call +} + +// UpdateIdentityProvider is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - identityProviderId string +// - federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate +func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}, federationIdentityProviderUpdate interface{}) *FederatedAuthenticationApi_UpdateIdentityProvider_Call { + return &FederatedAuthenticationApi_UpdateIdentityProvider_Call{Call: _e.mock.On("UpdateIdentityProvider", ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate)} +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string, federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate)) *FederatedAuthenticationApi_UpdateIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.FederationIdentityProviderUpdate)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) Return(_a0 admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) RunAndReturn(run func(context.Context, string, string, *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// UpdateIdentityProviderExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) UpdateIdentityProviderExecute(r admin.UpdateIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateIdentityProviderExecute") + } + + var r0 *admin.FederationIdentityProvider + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateIdentityProviderApiRequest) *admin.FederationIdentityProvider); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.FederationIdentityProvider) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateIdentityProviderApiRequest) *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.UpdateIdentityProviderApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateIdentityProviderExecute' +type FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call struct { + *mock.Call +} + +// UpdateIdentityProviderExecute is a helper method to define mock.On call +// - r admin.UpdateIdentityProviderApiRequest +func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call { + return &FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call{Call: _e.mock.On("UpdateIdentityProviderExecute", r)} +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call) Run(run func(r admin.UpdateIdentityProviderApiRequest)) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateIdentityProviderApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call) Return(_a0 *admin.FederationIdentityProvider, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call) RunAndReturn(run func(admin.UpdateIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateIdentityProviderWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) UpdateIdentityProviderWithParams(ctx context.Context, args *admin.UpdateIdentityProviderApiParams) admin.UpdateIdentityProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateIdentityProviderWithParams") + } + + var r0 admin.UpdateIdentityProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateIdentityProviderApiParams) admin.UpdateIdentityProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateIdentityProviderApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateIdentityProviderWithParams' +type FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call struct { + *mock.Call +} + +// UpdateIdentityProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateIdentityProviderApiParams +func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call { + return &FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call{Call: _e.mock.On("UpdateIdentityProviderWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateIdentityProviderApiParams)) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateIdentityProviderApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call) Return(_a0 admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateIdentityProviderApiParams) admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId, authFederationRoleMapping +func (_m *FederatedAuthenticationApi) UpdateRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest { + ret := _m.Called(ctx, federationSettingsId, id, orgId, authFederationRoleMapping) + + if len(ret) == 0 { + panic("no return value specified for UpdateRoleMapping") + } + + var r0 admin.UpdateRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest); ok { + r0 = rf(ctx, federationSettingsId, id, orgId, authFederationRoleMapping) + } else { + r0 = ret.Get(0).(admin.UpdateRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateRoleMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoleMapping' +type FederatedAuthenticationApi_UpdateRoleMapping_Call struct { + *mock.Call +} + +// UpdateRoleMapping is a helper method to define mock.On call +// - ctx context.Context +// - federationSettingsId string +// - id string +// - orgId string +// - authFederationRoleMapping *admin.AuthFederationRoleMapping +func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}, authFederationRoleMapping interface{}) *FederatedAuthenticationApi_UpdateRoleMapping_Call { + return &FederatedAuthenticationApi_UpdateRoleMapping_Call{Call: _e.mock.On("UpdateRoleMapping", ctx, federationSettingsId, id, orgId, authFederationRoleMapping)} +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping)) *FederatedAuthenticationApi_UpdateRoleMapping_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.AuthFederationRoleMapping)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) Return(_a0 admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMapping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMapping_Call { + _c.Call.Return(run) + return _c +} + +// UpdateRoleMappingExecute provides a mock function with given fields: r +func (_m *FederatedAuthenticationApi) UpdateRoleMappingExecute(r admin.UpdateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateRoleMappingExecute") + } + + var r0 *admin.AuthFederationRoleMapping + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateRoleMappingApiRequest) *admin.AuthFederationRoleMapping); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AuthFederationRoleMapping) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateRoleMappingApiRequest) *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.UpdateRoleMappingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// FederatedAuthenticationApi_UpdateRoleMappingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoleMappingExecute' +type FederatedAuthenticationApi_UpdateRoleMappingExecute_Call struct { + *mock.Call +} + +// UpdateRoleMappingExecute is a helper method to define mock.On call +// - r admin.UpdateRoleMappingApiRequest +func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call { + return &FederatedAuthenticationApi_UpdateRoleMappingExecute_Call{Call: _e.mock.On("UpdateRoleMappingExecute", r)} +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call) Run(run func(r admin.UpdateRoleMappingApiRequest)) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateRoleMappingApiRequest)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call) Return(_a0 *admin.AuthFederationRoleMapping, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call) RunAndReturn(run func(admin.UpdateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateRoleMappingWithParams provides a mock function with given fields: ctx, args +func (_m *FederatedAuthenticationApi) UpdateRoleMappingWithParams(ctx context.Context, args *admin.UpdateRoleMappingApiParams) admin.UpdateRoleMappingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateRoleMappingWithParams") + } + + var r0 admin.UpdateRoleMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateRoleMappingApiParams) admin.UpdateRoleMappingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateRoleMappingApiRequest) + } + + return r0 +} + +// FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoleMappingWithParams' +type FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call struct { + *mock.Call +} + +// UpdateRoleMappingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateRoleMappingApiParams +func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call { + return &FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call{Call: _e.mock.On("UpdateRoleMappingWithParams", ctx, args)} +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateRoleMappingApiParams)) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateRoleMappingApiParams)) + }) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call) Return(_a0 admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateRoleMappingApiParams) admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewFederatedAuthenticationApi creates a new instance of FederatedAuthenticationApi. 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 NewFederatedAuthenticationApi(t interface { + mock.TestingT + Cleanup(func()) +}) *FederatedAuthenticationApi { + mock := &FederatedAuthenticationApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/global_clusters_api.go b/mockadmin/global_clusters_api.go new file mode 100644 index 000000000..36fe4b05b --- /dev/null +++ b/mockadmin/global_clusters_api.go @@ -0,0 +1,852 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// GlobalClustersApi is an autogenerated mock type for the GlobalClustersApi type +type GlobalClustersApi struct { + mock.Mock +} + +type GlobalClustersApi_Expecter struct { + mock *mock.Mock +} + +func (_m *GlobalClustersApi) EXPECT() *GlobalClustersApi_Expecter { + return &GlobalClustersApi_Expecter{mock: &_m.Mock} +} + +// CreateCustomZoneMapping provides a mock function with given fields: ctx, groupId, clusterName, customZoneMappings +func (_m *GlobalClustersApi) CreateCustomZoneMapping(ctx context.Context, groupId string, clusterName string, customZoneMappings *admin.CustomZoneMappings) admin.CreateCustomZoneMappingApiRequest { + ret := _m.Called(ctx, groupId, clusterName, customZoneMappings) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomZoneMapping") + } + + var r0 admin.CreateCustomZoneMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.CustomZoneMappings) admin.CreateCustomZoneMappingApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, customZoneMappings) + } else { + r0 = ret.Get(0).(admin.CreateCustomZoneMappingApiRequest) + } + + return r0 +} + +// GlobalClustersApi_CreateCustomZoneMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomZoneMapping' +type GlobalClustersApi_CreateCustomZoneMapping_Call struct { + *mock.Call +} + +// CreateCustomZoneMapping is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - customZoneMappings *admin.CustomZoneMappings +func (_e *GlobalClustersApi_Expecter) CreateCustomZoneMapping(ctx interface{}, groupId interface{}, clusterName interface{}, customZoneMappings interface{}) *GlobalClustersApi_CreateCustomZoneMapping_Call { + return &GlobalClustersApi_CreateCustomZoneMapping_Call{Call: _e.mock.On("CreateCustomZoneMapping", ctx, groupId, clusterName, customZoneMappings)} +} + +func (_c *GlobalClustersApi_CreateCustomZoneMapping_Call) Run(run func(ctx context.Context, groupId string, clusterName string, customZoneMappings *admin.CustomZoneMappings)) *GlobalClustersApi_CreateCustomZoneMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.CustomZoneMappings)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMapping_Call) Return(_a0 admin.CreateCustomZoneMappingApiRequest) *GlobalClustersApi_CreateCustomZoneMapping_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMapping_Call) RunAndReturn(run func(context.Context, string, string, *admin.CustomZoneMappings) admin.CreateCustomZoneMappingApiRequest) *GlobalClustersApi_CreateCustomZoneMapping_Call { + _c.Call.Return(run) + return _c +} + +// CreateCustomZoneMappingExecute provides a mock function with given fields: r +func (_m *GlobalClustersApi) CreateCustomZoneMappingExecute(r admin.CreateCustomZoneMappingApiRequest) (*admin.GeoSharding, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomZoneMappingExecute") + } + + var r0 *admin.GeoSharding + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateCustomZoneMappingApiRequest) (*admin.GeoSharding, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateCustomZoneMappingApiRequest) *admin.GeoSharding); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GeoSharding) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateCustomZoneMappingApiRequest) *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.CreateCustomZoneMappingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// GlobalClustersApi_CreateCustomZoneMappingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomZoneMappingExecute' +type GlobalClustersApi_CreateCustomZoneMappingExecute_Call struct { + *mock.Call +} + +// CreateCustomZoneMappingExecute is a helper method to define mock.On call +// - r admin.CreateCustomZoneMappingApiRequest +func (_e *GlobalClustersApi_Expecter) CreateCustomZoneMappingExecute(r interface{}) *GlobalClustersApi_CreateCustomZoneMappingExecute_Call { + return &GlobalClustersApi_CreateCustomZoneMappingExecute_Call{Call: _e.mock.On("CreateCustomZoneMappingExecute", r)} +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingExecute_Call) Run(run func(r admin.CreateCustomZoneMappingApiRequest)) *GlobalClustersApi_CreateCustomZoneMappingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateCustomZoneMappingApiRequest)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingExecute_Call) Return(_a0 *admin.GeoSharding, _a1 *http.Response, _a2 error) *GlobalClustersApi_CreateCustomZoneMappingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingExecute_Call) RunAndReturn(run func(admin.CreateCustomZoneMappingApiRequest) (*admin.GeoSharding, *http.Response, error)) *GlobalClustersApi_CreateCustomZoneMappingExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateCustomZoneMappingWithParams provides a mock function with given fields: ctx, args +func (_m *GlobalClustersApi) CreateCustomZoneMappingWithParams(ctx context.Context, args *admin.CreateCustomZoneMappingApiParams) admin.CreateCustomZoneMappingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateCustomZoneMappingWithParams") + } + + var r0 admin.CreateCustomZoneMappingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateCustomZoneMappingApiParams) admin.CreateCustomZoneMappingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateCustomZoneMappingApiRequest) + } + + return r0 +} + +// GlobalClustersApi_CreateCustomZoneMappingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomZoneMappingWithParams' +type GlobalClustersApi_CreateCustomZoneMappingWithParams_Call struct { + *mock.Call +} + +// CreateCustomZoneMappingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateCustomZoneMappingApiParams +func (_e *GlobalClustersApi_Expecter) CreateCustomZoneMappingWithParams(ctx interface{}, args interface{}) *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call { + return &GlobalClustersApi_CreateCustomZoneMappingWithParams_Call{Call: _e.mock.On("CreateCustomZoneMappingWithParams", ctx, args)} +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateCustomZoneMappingApiParams)) *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateCustomZoneMappingApiParams)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call) Return(_a0 admin.CreateCustomZoneMappingApiRequest) *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateCustomZoneMappingApiParams) admin.CreateCustomZoneMappingApiRequest) *GlobalClustersApi_CreateCustomZoneMappingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateManagedNamespace provides a mock function with given fields: ctx, groupId, clusterName, managedNamespace +func (_m *GlobalClustersApi) CreateManagedNamespace(ctx context.Context, groupId string, clusterName string, managedNamespace *admin.ManagedNamespace) admin.CreateManagedNamespaceApiRequest { + ret := _m.Called(ctx, groupId, clusterName, managedNamespace) + + if len(ret) == 0 { + panic("no return value specified for CreateManagedNamespace") + } + + var r0 admin.CreateManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ManagedNamespace) admin.CreateManagedNamespaceApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, managedNamespace) + } else { + r0 = ret.Get(0).(admin.CreateManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_CreateManagedNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateManagedNamespace' +type GlobalClustersApi_CreateManagedNamespace_Call struct { + *mock.Call +} + +// CreateManagedNamespace is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - managedNamespace *admin.ManagedNamespace +func (_e *GlobalClustersApi_Expecter) CreateManagedNamespace(ctx interface{}, groupId interface{}, clusterName interface{}, managedNamespace interface{}) *GlobalClustersApi_CreateManagedNamespace_Call { + return &GlobalClustersApi_CreateManagedNamespace_Call{Call: _e.mock.On("CreateManagedNamespace", ctx, groupId, clusterName, managedNamespace)} +} + +func (_c *GlobalClustersApi_CreateManagedNamespace_Call) Run(run func(ctx context.Context, groupId string, clusterName string, managedNamespace *admin.ManagedNamespace)) *GlobalClustersApi_CreateManagedNamespace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ManagedNamespace)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespace_Call) Return(_a0 admin.CreateManagedNamespaceApiRequest) *GlobalClustersApi_CreateManagedNamespace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespace_Call) RunAndReturn(run func(context.Context, string, string, *admin.ManagedNamespace) admin.CreateManagedNamespaceApiRequest) *GlobalClustersApi_CreateManagedNamespace_Call { + _c.Call.Return(run) + return _c +} + +// CreateManagedNamespaceExecute provides a mock function with given fields: r +func (_m *GlobalClustersApi) CreateManagedNamespaceExecute(r admin.CreateManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateManagedNamespaceExecute") + } + + var r0 *admin.GeoSharding + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateManagedNamespaceApiRequest) *admin.GeoSharding); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GeoSharding) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateManagedNamespaceApiRequest) *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.CreateManagedNamespaceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// GlobalClustersApi_CreateManagedNamespaceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateManagedNamespaceExecute' +type GlobalClustersApi_CreateManagedNamespaceExecute_Call struct { + *mock.Call +} + +// CreateManagedNamespaceExecute is a helper method to define mock.On call +// - r admin.CreateManagedNamespaceApiRequest +func (_e *GlobalClustersApi_Expecter) CreateManagedNamespaceExecute(r interface{}) *GlobalClustersApi_CreateManagedNamespaceExecute_Call { + return &GlobalClustersApi_CreateManagedNamespaceExecute_Call{Call: _e.mock.On("CreateManagedNamespaceExecute", r)} +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceExecute_Call) Run(run func(r admin.CreateManagedNamespaceApiRequest)) *GlobalClustersApi_CreateManagedNamespaceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateManagedNamespaceApiRequest)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceExecute_Call) Return(_a0 *admin.GeoSharding, _a1 *http.Response, _a2 error) *GlobalClustersApi_CreateManagedNamespaceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceExecute_Call) RunAndReturn(run func(admin.CreateManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)) *GlobalClustersApi_CreateManagedNamespaceExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateManagedNamespaceWithParams provides a mock function with given fields: ctx, args +func (_m *GlobalClustersApi) CreateManagedNamespaceWithParams(ctx context.Context, args *admin.CreateManagedNamespaceApiParams) admin.CreateManagedNamespaceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateManagedNamespaceWithParams") + } + + var r0 admin.CreateManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateManagedNamespaceApiParams) admin.CreateManagedNamespaceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_CreateManagedNamespaceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateManagedNamespaceWithParams' +type GlobalClustersApi_CreateManagedNamespaceWithParams_Call struct { + *mock.Call +} + +// CreateManagedNamespaceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateManagedNamespaceApiParams +func (_e *GlobalClustersApi_Expecter) CreateManagedNamespaceWithParams(ctx interface{}, args interface{}) *GlobalClustersApi_CreateManagedNamespaceWithParams_Call { + return &GlobalClustersApi_CreateManagedNamespaceWithParams_Call{Call: _e.mock.On("CreateManagedNamespaceWithParams", ctx, args)} +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateManagedNamespaceApiParams)) *GlobalClustersApi_CreateManagedNamespaceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateManagedNamespaceApiParams)) + }) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceWithParams_Call) Return(_a0 admin.CreateManagedNamespaceApiRequest) *GlobalClustersApi_CreateManagedNamespaceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_CreateManagedNamespaceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateManagedNamespaceApiParams) admin.CreateManagedNamespaceApiRequest) *GlobalClustersApi_CreateManagedNamespaceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllCustomZoneMappings provides a mock function with given fields: ctx, groupId, clusterName +func (_m *GlobalClustersApi) DeleteAllCustomZoneMappings(ctx context.Context, groupId string, clusterName string) admin.DeleteAllCustomZoneMappingsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllCustomZoneMappings") + } + + var r0 admin.DeleteAllCustomZoneMappingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteAllCustomZoneMappingsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.DeleteAllCustomZoneMappingsApiRequest) + } + + return r0 +} + +// GlobalClustersApi_DeleteAllCustomZoneMappings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllCustomZoneMappings' +type GlobalClustersApi_DeleteAllCustomZoneMappings_Call struct { + *mock.Call +} + +// DeleteAllCustomZoneMappings is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *GlobalClustersApi_Expecter) DeleteAllCustomZoneMappings(ctx interface{}, groupId interface{}, clusterName interface{}) *GlobalClustersApi_DeleteAllCustomZoneMappings_Call { + return &GlobalClustersApi_DeleteAllCustomZoneMappings_Call{Call: _e.mock.On("DeleteAllCustomZoneMappings", ctx, groupId, clusterName)} +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappings_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *GlobalClustersApi_DeleteAllCustomZoneMappings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappings_Call) Return(_a0 admin.DeleteAllCustomZoneMappingsApiRequest) *GlobalClustersApi_DeleteAllCustomZoneMappings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappings_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteAllCustomZoneMappingsApiRequest) *GlobalClustersApi_DeleteAllCustomZoneMappings_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllCustomZoneMappingsExecute provides a mock function with given fields: r +func (_m *GlobalClustersApi) DeleteAllCustomZoneMappingsExecute(r admin.DeleteAllCustomZoneMappingsApiRequest) (*admin.GeoSharding, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllCustomZoneMappingsExecute") + } + + var r0 *admin.GeoSharding + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteAllCustomZoneMappingsApiRequest) (*admin.GeoSharding, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteAllCustomZoneMappingsApiRequest) *admin.GeoSharding); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GeoSharding) + } + } + + if rf, ok := ret.Get(1).(func(admin.DeleteAllCustomZoneMappingsApiRequest) *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.DeleteAllCustomZoneMappingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllCustomZoneMappingsExecute' +type GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call struct { + *mock.Call +} + +// DeleteAllCustomZoneMappingsExecute is a helper method to define mock.On call +// - r admin.DeleteAllCustomZoneMappingsApiRequest +func (_e *GlobalClustersApi_Expecter) DeleteAllCustomZoneMappingsExecute(r interface{}) *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call { + return &GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call{Call: _e.mock.On("DeleteAllCustomZoneMappingsExecute", r)} +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call) Run(run func(r admin.DeleteAllCustomZoneMappingsApiRequest)) *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteAllCustomZoneMappingsApiRequest)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call) Return(_a0 *admin.GeoSharding, _a1 *http.Response, _a2 error) *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call) RunAndReturn(run func(admin.DeleteAllCustomZoneMappingsApiRequest) (*admin.GeoSharding, *http.Response, error)) *GlobalClustersApi_DeleteAllCustomZoneMappingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAllCustomZoneMappingsWithParams provides a mock function with given fields: ctx, args +func (_m *GlobalClustersApi) DeleteAllCustomZoneMappingsWithParams(ctx context.Context, args *admin.DeleteAllCustomZoneMappingsApiParams) admin.DeleteAllCustomZoneMappingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteAllCustomZoneMappingsWithParams") + } + + var r0 admin.DeleteAllCustomZoneMappingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteAllCustomZoneMappingsApiParams) admin.DeleteAllCustomZoneMappingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteAllCustomZoneMappingsApiRequest) + } + + return r0 +} + +// GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllCustomZoneMappingsWithParams' +type GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call struct { + *mock.Call +} + +// DeleteAllCustomZoneMappingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteAllCustomZoneMappingsApiParams +func (_e *GlobalClustersApi_Expecter) DeleteAllCustomZoneMappingsWithParams(ctx interface{}, args interface{}) *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call { + return &GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call{Call: _e.mock.On("DeleteAllCustomZoneMappingsWithParams", ctx, args)} +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteAllCustomZoneMappingsApiParams)) *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteAllCustomZoneMappingsApiParams)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call) Return(_a0 admin.DeleteAllCustomZoneMappingsApiRequest) *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAllCustomZoneMappingsApiParams) admin.DeleteAllCustomZoneMappingsApiRequest) *GlobalClustersApi_DeleteAllCustomZoneMappingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteManagedNamespace provides a mock function with given fields: ctx, clusterName, groupId +func (_m *GlobalClustersApi) DeleteManagedNamespace(ctx context.Context, clusterName string, groupId string) admin.DeleteManagedNamespaceApiRequest { + ret := _m.Called(ctx, clusterName, groupId) + + if len(ret) == 0 { + panic("no return value specified for DeleteManagedNamespace") + } + + var r0 admin.DeleteManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteManagedNamespaceApiRequest); ok { + r0 = rf(ctx, clusterName, groupId) + } else { + r0 = ret.Get(0).(admin.DeleteManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_DeleteManagedNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManagedNamespace' +type GlobalClustersApi_DeleteManagedNamespace_Call struct { + *mock.Call +} + +// DeleteManagedNamespace is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - groupId string +func (_e *GlobalClustersApi_Expecter) DeleteManagedNamespace(ctx interface{}, clusterName interface{}, groupId interface{}) *GlobalClustersApi_DeleteManagedNamespace_Call { + return &GlobalClustersApi_DeleteManagedNamespace_Call{Call: _e.mock.On("DeleteManagedNamespace", ctx, clusterName, groupId)} +} + +func (_c *GlobalClustersApi_DeleteManagedNamespace_Call) Run(run func(ctx context.Context, clusterName string, groupId string)) *GlobalClustersApi_DeleteManagedNamespace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespace_Call) Return(_a0 admin.DeleteManagedNamespaceApiRequest) *GlobalClustersApi_DeleteManagedNamespace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespace_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteManagedNamespaceApiRequest) *GlobalClustersApi_DeleteManagedNamespace_Call { + _c.Call.Return(run) + return _c +} + +// DeleteManagedNamespaceExecute provides a mock function with given fields: r +func (_m *GlobalClustersApi) DeleteManagedNamespaceExecute(r admin.DeleteManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteManagedNamespaceExecute") + } + + var r0 *admin.GeoSharding + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteManagedNamespaceApiRequest) *admin.GeoSharding); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GeoSharding) + } + } + + if rf, ok := ret.Get(1).(func(admin.DeleteManagedNamespaceApiRequest) *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.DeleteManagedNamespaceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// GlobalClustersApi_DeleteManagedNamespaceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManagedNamespaceExecute' +type GlobalClustersApi_DeleteManagedNamespaceExecute_Call struct { + *mock.Call +} + +// DeleteManagedNamespaceExecute is a helper method to define mock.On call +// - r admin.DeleteManagedNamespaceApiRequest +func (_e *GlobalClustersApi_Expecter) DeleteManagedNamespaceExecute(r interface{}) *GlobalClustersApi_DeleteManagedNamespaceExecute_Call { + return &GlobalClustersApi_DeleteManagedNamespaceExecute_Call{Call: _e.mock.On("DeleteManagedNamespaceExecute", r)} +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceExecute_Call) Run(run func(r admin.DeleteManagedNamespaceApiRequest)) *GlobalClustersApi_DeleteManagedNamespaceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteManagedNamespaceApiRequest)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceExecute_Call) Return(_a0 *admin.GeoSharding, _a1 *http.Response, _a2 error) *GlobalClustersApi_DeleteManagedNamespaceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceExecute_Call) RunAndReturn(run func(admin.DeleteManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)) *GlobalClustersApi_DeleteManagedNamespaceExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteManagedNamespaceWithParams provides a mock function with given fields: ctx, args +func (_m *GlobalClustersApi) DeleteManagedNamespaceWithParams(ctx context.Context, args *admin.DeleteManagedNamespaceApiParams) admin.DeleteManagedNamespaceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteManagedNamespaceWithParams") + } + + var r0 admin.DeleteManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteManagedNamespaceApiParams) admin.DeleteManagedNamespaceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_DeleteManagedNamespaceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManagedNamespaceWithParams' +type GlobalClustersApi_DeleteManagedNamespaceWithParams_Call struct { + *mock.Call +} + +// DeleteManagedNamespaceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteManagedNamespaceApiParams +func (_e *GlobalClustersApi_Expecter) DeleteManagedNamespaceWithParams(ctx interface{}, args interface{}) *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call { + return &GlobalClustersApi_DeleteManagedNamespaceWithParams_Call{Call: _e.mock.On("DeleteManagedNamespaceWithParams", ctx, args)} +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteManagedNamespaceApiParams)) *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteManagedNamespaceApiParams)) + }) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call) Return(_a0 admin.DeleteManagedNamespaceApiRequest) *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteManagedNamespaceApiParams) admin.DeleteManagedNamespaceApiRequest) *GlobalClustersApi_DeleteManagedNamespaceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetManagedNamespace provides a mock function with given fields: ctx, groupId, clusterName +func (_m *GlobalClustersApi) GetManagedNamespace(ctx context.Context, groupId string, clusterName string) admin.GetManagedNamespaceApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetManagedNamespace") + } + + var r0 admin.GetManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetManagedNamespaceApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_GetManagedNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedNamespace' +type GlobalClustersApi_GetManagedNamespace_Call struct { + *mock.Call +} + +// GetManagedNamespace is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *GlobalClustersApi_Expecter) GetManagedNamespace(ctx interface{}, groupId interface{}, clusterName interface{}) *GlobalClustersApi_GetManagedNamespace_Call { + return &GlobalClustersApi_GetManagedNamespace_Call{Call: _e.mock.On("GetManagedNamespace", ctx, groupId, clusterName)} +} + +func (_c *GlobalClustersApi_GetManagedNamespace_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *GlobalClustersApi_GetManagedNamespace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespace_Call) Return(_a0 admin.GetManagedNamespaceApiRequest) *GlobalClustersApi_GetManagedNamespace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespace_Call) RunAndReturn(run func(context.Context, string, string) admin.GetManagedNamespaceApiRequest) *GlobalClustersApi_GetManagedNamespace_Call { + _c.Call.Return(run) + return _c +} + +// GetManagedNamespaceExecute provides a mock function with given fields: r +func (_m *GlobalClustersApi) GetManagedNamespaceExecute(r admin.GetManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetManagedNamespaceExecute") + } + + var r0 *admin.GeoSharding + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetManagedNamespaceApiRequest) *admin.GeoSharding); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GeoSharding) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetManagedNamespaceApiRequest) *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.GetManagedNamespaceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// GlobalClustersApi_GetManagedNamespaceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedNamespaceExecute' +type GlobalClustersApi_GetManagedNamespaceExecute_Call struct { + *mock.Call +} + +// GetManagedNamespaceExecute is a helper method to define mock.On call +// - r admin.GetManagedNamespaceApiRequest +func (_e *GlobalClustersApi_Expecter) GetManagedNamespaceExecute(r interface{}) *GlobalClustersApi_GetManagedNamespaceExecute_Call { + return &GlobalClustersApi_GetManagedNamespaceExecute_Call{Call: _e.mock.On("GetManagedNamespaceExecute", r)} +} + +func (_c *GlobalClustersApi_GetManagedNamespaceExecute_Call) Run(run func(r admin.GetManagedNamespaceApiRequest)) *GlobalClustersApi_GetManagedNamespaceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetManagedNamespaceApiRequest)) + }) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespaceExecute_Call) Return(_a0 *admin.GeoSharding, _a1 *http.Response, _a2 error) *GlobalClustersApi_GetManagedNamespaceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespaceExecute_Call) RunAndReturn(run func(admin.GetManagedNamespaceApiRequest) (*admin.GeoSharding, *http.Response, error)) *GlobalClustersApi_GetManagedNamespaceExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetManagedNamespaceWithParams provides a mock function with given fields: ctx, args +func (_m *GlobalClustersApi) GetManagedNamespaceWithParams(ctx context.Context, args *admin.GetManagedNamespaceApiParams) admin.GetManagedNamespaceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetManagedNamespaceWithParams") + } + + var r0 admin.GetManagedNamespaceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetManagedNamespaceApiParams) admin.GetManagedNamespaceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetManagedNamespaceApiRequest) + } + + return r0 +} + +// GlobalClustersApi_GetManagedNamespaceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedNamespaceWithParams' +type GlobalClustersApi_GetManagedNamespaceWithParams_Call struct { + *mock.Call +} + +// GetManagedNamespaceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetManagedNamespaceApiParams +func (_e *GlobalClustersApi_Expecter) GetManagedNamespaceWithParams(ctx interface{}, args interface{}) *GlobalClustersApi_GetManagedNamespaceWithParams_Call { + return &GlobalClustersApi_GetManagedNamespaceWithParams_Call{Call: _e.mock.On("GetManagedNamespaceWithParams", ctx, args)} +} + +func (_c *GlobalClustersApi_GetManagedNamespaceWithParams_Call) Run(run func(ctx context.Context, args *admin.GetManagedNamespaceApiParams)) *GlobalClustersApi_GetManagedNamespaceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetManagedNamespaceApiParams)) + }) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespaceWithParams_Call) Return(_a0 admin.GetManagedNamespaceApiRequest) *GlobalClustersApi_GetManagedNamespaceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *GlobalClustersApi_GetManagedNamespaceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetManagedNamespaceApiParams) admin.GetManagedNamespaceApiRequest) *GlobalClustersApi_GetManagedNamespaceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewGlobalClustersApi creates a new instance of GlobalClustersApi. 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 NewGlobalClustersApi(t interface { + mock.TestingT + Cleanup(func()) +}) *GlobalClustersApi { + mock := &GlobalClustersApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/invoices_api.go b/mockadmin/invoices_api.go new file mode 100644 index 000000000..08dcd2286 --- /dev/null +++ b/mockadmin/invoices_api.go @@ -0,0 +1,1004 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// InvoicesApi is an autogenerated mock type for the InvoicesApi type +type InvoicesApi struct { + mock.Mock +} + +type InvoicesApi_Expecter struct { + mock *mock.Mock +} + +func (_m *InvoicesApi) EXPECT() *InvoicesApi_Expecter { + return &InvoicesApi_Expecter{mock: &_m.Mock} +} + +// CreateCostExplorerQueryProcess provides a mock function with given fields: ctx, orgId, costExplorerFilterRequestBody +func (_m *InvoicesApi) CreateCostExplorerQueryProcess(ctx context.Context, orgId string, costExplorerFilterRequestBody *admin.CostExplorerFilterRequestBody) admin.CreateCostExplorerQueryProcessApiRequest { + ret := _m.Called(ctx, orgId, costExplorerFilterRequestBody) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcess") + } + + var r0 admin.CreateCostExplorerQueryProcessApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CostExplorerFilterRequestBody) admin.CreateCostExplorerQueryProcessApiRequest); ok { + r0 = rf(ctx, orgId, costExplorerFilterRequestBody) + } else { + r0 = ret.Get(0).(admin.CreateCostExplorerQueryProcessApiRequest) + } + + return r0 +} + +// InvoicesApi_CreateCostExplorerQueryProcess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcess' +type InvoicesApi_CreateCostExplorerQueryProcess_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcess is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - costExplorerFilterRequestBody *admin.CostExplorerFilterRequestBody +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcess(ctx interface{}, orgId interface{}, costExplorerFilterRequestBody interface{}) *InvoicesApi_CreateCostExplorerQueryProcess_Call { + return &InvoicesApi_CreateCostExplorerQueryProcess_Call{Call: _e.mock.On("CreateCostExplorerQueryProcess", ctx, orgId, costExplorerFilterRequestBody)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess_Call) Run(run func(ctx context.Context, orgId string, costExplorerFilterRequestBody *admin.CostExplorerFilterRequestBody)) *InvoicesApi_CreateCostExplorerQueryProcess_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CostExplorerFilterRequestBody)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess_Call) Return(_a0 admin.CreateCostExplorerQueryProcessApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess_Call) RunAndReturn(run func(context.Context, string, *admin.CostExplorerFilterRequestBody) admin.CreateCostExplorerQueryProcessApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess_Call { + _c.Call.Return(run) + return _c +} + +// CreateCostExplorerQueryProcess1 provides a mock function with given fields: ctx, orgId, token +func (_m *InvoicesApi) CreateCostExplorerQueryProcess1(ctx context.Context, orgId string, token string) admin.CreateCostExplorerQueryProcess1ApiRequest { + ret := _m.Called(ctx, orgId, token) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcess1") + } + + var r0 admin.CreateCostExplorerQueryProcess1ApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.CreateCostExplorerQueryProcess1ApiRequest); ok { + r0 = rf(ctx, orgId, token) + } else { + r0 = ret.Get(0).(admin.CreateCostExplorerQueryProcess1ApiRequest) + } + + return r0 +} + +// InvoicesApi_CreateCostExplorerQueryProcess1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcess1' +type InvoicesApi_CreateCostExplorerQueryProcess1_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcess1 is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - token string +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcess1(ctx interface{}, orgId interface{}, token interface{}) *InvoicesApi_CreateCostExplorerQueryProcess1_Call { + return &InvoicesApi_CreateCostExplorerQueryProcess1_Call{Call: _e.mock.On("CreateCostExplorerQueryProcess1", ctx, orgId, token)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1_Call) Run(run func(ctx context.Context, orgId string, token string)) *InvoicesApi_CreateCostExplorerQueryProcess1_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1_Call) Return(_a0 admin.CreateCostExplorerQueryProcess1ApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess1_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1_Call) RunAndReturn(run func(context.Context, string, string) admin.CreateCostExplorerQueryProcess1ApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess1_Call { + _c.Call.Return(run) + return _c +} + +// CreateCostExplorerQueryProcess1Execute provides a mock function with given fields: r +func (_m *InvoicesApi) CreateCostExplorerQueryProcess1Execute(r admin.CreateCostExplorerQueryProcess1ApiRequest) (string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcess1Execute") + } + + var r0 string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateCostExplorerQueryProcess1ApiRequest) (string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateCostExplorerQueryProcess1ApiRequest) string); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(admin.CreateCostExplorerQueryProcess1ApiRequest) *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.CreateCostExplorerQueryProcess1ApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcess1Execute' +type InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcess1Execute is a helper method to define mock.On call +// - r admin.CreateCostExplorerQueryProcess1ApiRequest +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcess1Execute(r interface{}) *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call { + return &InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call{Call: _e.mock.On("CreateCostExplorerQueryProcess1Execute", r)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call) Run(run func(r admin.CreateCostExplorerQueryProcess1ApiRequest)) *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateCostExplorerQueryProcess1ApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call) RunAndReturn(run func(admin.CreateCostExplorerQueryProcess1ApiRequest) (string, *http.Response, error)) *InvoicesApi_CreateCostExplorerQueryProcess1Execute_Call { + _c.Call.Return(run) + return _c +} + +// CreateCostExplorerQueryProcess1WithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) CreateCostExplorerQueryProcess1WithParams(ctx context.Context, args *admin.CreateCostExplorerQueryProcess1ApiParams) admin.CreateCostExplorerQueryProcess1ApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcess1WithParams") + } + + var r0 admin.CreateCostExplorerQueryProcess1ApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateCostExplorerQueryProcess1ApiParams) admin.CreateCostExplorerQueryProcess1ApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateCostExplorerQueryProcess1ApiRequest) + } + + return r0 +} + +// InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcess1WithParams' +type InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcess1WithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateCostExplorerQueryProcess1ApiParams +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcess1WithParams(ctx interface{}, args interface{}) *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call { + return &InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call{Call: _e.mock.On("CreateCostExplorerQueryProcess1WithParams", ctx, args)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call) Run(run func(ctx context.Context, args *admin.CreateCostExplorerQueryProcess1ApiParams)) *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateCostExplorerQueryProcess1ApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call) Return(_a0 admin.CreateCostExplorerQueryProcess1ApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateCostExplorerQueryProcess1ApiParams) admin.CreateCostExplorerQueryProcess1ApiRequest) *InvoicesApi_CreateCostExplorerQueryProcess1WithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateCostExplorerQueryProcessExecute provides a mock function with given fields: r +func (_m *InvoicesApi) CreateCostExplorerQueryProcessExecute(r admin.CreateCostExplorerQueryProcessApiRequest) (*admin.CostExplorerFilterResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcessExecute") + } + + var r0 *admin.CostExplorerFilterResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateCostExplorerQueryProcessApiRequest) (*admin.CostExplorerFilterResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateCostExplorerQueryProcessApiRequest) *admin.CostExplorerFilterResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CostExplorerFilterResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateCostExplorerQueryProcessApiRequest) *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.CreateCostExplorerQueryProcessApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_CreateCostExplorerQueryProcessExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcessExecute' +type InvoicesApi_CreateCostExplorerQueryProcessExecute_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcessExecute is a helper method to define mock.On call +// - r admin.CreateCostExplorerQueryProcessApiRequest +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcessExecute(r interface{}) *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call { + return &InvoicesApi_CreateCostExplorerQueryProcessExecute_Call{Call: _e.mock.On("CreateCostExplorerQueryProcessExecute", r)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call) Run(run func(r admin.CreateCostExplorerQueryProcessApiRequest)) *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateCostExplorerQueryProcessApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call) Return(_a0 *admin.CostExplorerFilterResponse, _a1 *http.Response, _a2 error) *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call) RunAndReturn(run func(admin.CreateCostExplorerQueryProcessApiRequest) (*admin.CostExplorerFilterResponse, *http.Response, error)) *InvoicesApi_CreateCostExplorerQueryProcessExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateCostExplorerQueryProcessWithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) CreateCostExplorerQueryProcessWithParams(ctx context.Context, args *admin.CreateCostExplorerQueryProcessApiParams) admin.CreateCostExplorerQueryProcessApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateCostExplorerQueryProcessWithParams") + } + + var r0 admin.CreateCostExplorerQueryProcessApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateCostExplorerQueryProcessApiParams) admin.CreateCostExplorerQueryProcessApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateCostExplorerQueryProcessApiRequest) + } + + return r0 +} + +// InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCostExplorerQueryProcessWithParams' +type InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call struct { + *mock.Call +} + +// CreateCostExplorerQueryProcessWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateCostExplorerQueryProcessApiParams +func (_e *InvoicesApi_Expecter) CreateCostExplorerQueryProcessWithParams(ctx interface{}, args interface{}) *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call { + return &InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call{Call: _e.mock.On("CreateCostExplorerQueryProcessWithParams", ctx, args)} +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateCostExplorerQueryProcessApiParams)) *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateCostExplorerQueryProcessApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call) Return(_a0 admin.CreateCostExplorerQueryProcessApiRequest) *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateCostExplorerQueryProcessApiParams) admin.CreateCostExplorerQueryProcessApiRequest) *InvoicesApi_CreateCostExplorerQueryProcessWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DownloadInvoiceCSV provides a mock function with given fields: ctx, orgId, invoiceId +func (_m *InvoicesApi) DownloadInvoiceCSV(ctx context.Context, orgId string, invoiceId string) admin.DownloadInvoiceCSVApiRequest { + ret := _m.Called(ctx, orgId, invoiceId) + + if len(ret) == 0 { + panic("no return value specified for DownloadInvoiceCSV") + } + + var r0 admin.DownloadInvoiceCSVApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DownloadInvoiceCSVApiRequest); ok { + r0 = rf(ctx, orgId, invoiceId) + } else { + r0 = ret.Get(0).(admin.DownloadInvoiceCSVApiRequest) + } + + return r0 +} + +// InvoicesApi_DownloadInvoiceCSV_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadInvoiceCSV' +type InvoicesApi_DownloadInvoiceCSV_Call struct { + *mock.Call +} + +// DownloadInvoiceCSV is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - invoiceId string +func (_e *InvoicesApi_Expecter) DownloadInvoiceCSV(ctx interface{}, orgId interface{}, invoiceId interface{}) *InvoicesApi_DownloadInvoiceCSV_Call { + return &InvoicesApi_DownloadInvoiceCSV_Call{Call: _e.mock.On("DownloadInvoiceCSV", ctx, orgId, invoiceId)} +} + +func (_c *InvoicesApi_DownloadInvoiceCSV_Call) Run(run func(ctx context.Context, orgId string, invoiceId string)) *InvoicesApi_DownloadInvoiceCSV_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSV_Call) Return(_a0 admin.DownloadInvoiceCSVApiRequest) *InvoicesApi_DownloadInvoiceCSV_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSV_Call) RunAndReturn(run func(context.Context, string, string) admin.DownloadInvoiceCSVApiRequest) *InvoicesApi_DownloadInvoiceCSV_Call { + _c.Call.Return(run) + return _c +} + +// DownloadInvoiceCSVExecute provides a mock function with given fields: r +func (_m *InvoicesApi) DownloadInvoiceCSVExecute(r admin.DownloadInvoiceCSVApiRequest) (string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DownloadInvoiceCSVExecute") + } + + var r0 string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DownloadInvoiceCSVApiRequest) (string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DownloadInvoiceCSVApiRequest) string); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(admin.DownloadInvoiceCSVApiRequest) *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.DownloadInvoiceCSVApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_DownloadInvoiceCSVExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadInvoiceCSVExecute' +type InvoicesApi_DownloadInvoiceCSVExecute_Call struct { + *mock.Call +} + +// DownloadInvoiceCSVExecute is a helper method to define mock.On call +// - r admin.DownloadInvoiceCSVApiRequest +func (_e *InvoicesApi_Expecter) DownloadInvoiceCSVExecute(r interface{}) *InvoicesApi_DownloadInvoiceCSVExecute_Call { + return &InvoicesApi_DownloadInvoiceCSVExecute_Call{Call: _e.mock.On("DownloadInvoiceCSVExecute", r)} +} + +func (_c *InvoicesApi_DownloadInvoiceCSVExecute_Call) Run(run func(r admin.DownloadInvoiceCSVApiRequest)) *InvoicesApi_DownloadInvoiceCSVExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DownloadInvoiceCSVApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSVExecute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *InvoicesApi_DownloadInvoiceCSVExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSVExecute_Call) RunAndReturn(run func(admin.DownloadInvoiceCSVApiRequest) (string, *http.Response, error)) *InvoicesApi_DownloadInvoiceCSVExecute_Call { + _c.Call.Return(run) + return _c +} + +// DownloadInvoiceCSVWithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) DownloadInvoiceCSVWithParams(ctx context.Context, args *admin.DownloadInvoiceCSVApiParams) admin.DownloadInvoiceCSVApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DownloadInvoiceCSVWithParams") + } + + var r0 admin.DownloadInvoiceCSVApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadInvoiceCSVApiParams) admin.DownloadInvoiceCSVApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DownloadInvoiceCSVApiRequest) + } + + return r0 +} + +// InvoicesApi_DownloadInvoiceCSVWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadInvoiceCSVWithParams' +type InvoicesApi_DownloadInvoiceCSVWithParams_Call struct { + *mock.Call +} + +// DownloadInvoiceCSVWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DownloadInvoiceCSVApiParams +func (_e *InvoicesApi_Expecter) DownloadInvoiceCSVWithParams(ctx interface{}, args interface{}) *InvoicesApi_DownloadInvoiceCSVWithParams_Call { + return &InvoicesApi_DownloadInvoiceCSVWithParams_Call{Call: _e.mock.On("DownloadInvoiceCSVWithParams", ctx, args)} +} + +func (_c *InvoicesApi_DownloadInvoiceCSVWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadInvoiceCSVApiParams)) *InvoicesApi_DownloadInvoiceCSVWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DownloadInvoiceCSVApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSVWithParams_Call) Return(_a0 admin.DownloadInvoiceCSVApiRequest) *InvoicesApi_DownloadInvoiceCSVWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_DownloadInvoiceCSVWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadInvoiceCSVApiParams) admin.DownloadInvoiceCSVApiRequest) *InvoicesApi_DownloadInvoiceCSVWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetInvoice provides a mock function with given fields: ctx, orgId, invoiceId +func (_m *InvoicesApi) GetInvoice(ctx context.Context, orgId string, invoiceId string) admin.GetInvoiceApiRequest { + ret := _m.Called(ctx, orgId, invoiceId) + + if len(ret) == 0 { + panic("no return value specified for GetInvoice") + } + + var r0 admin.GetInvoiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetInvoiceApiRequest); ok { + r0 = rf(ctx, orgId, invoiceId) + } else { + r0 = ret.Get(0).(admin.GetInvoiceApiRequest) + } + + return r0 +} + +// InvoicesApi_GetInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInvoice' +type InvoicesApi_GetInvoice_Call struct { + *mock.Call +} + +// GetInvoice is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - invoiceId string +func (_e *InvoicesApi_Expecter) GetInvoice(ctx interface{}, orgId interface{}, invoiceId interface{}) *InvoicesApi_GetInvoice_Call { + return &InvoicesApi_GetInvoice_Call{Call: _e.mock.On("GetInvoice", ctx, orgId, invoiceId)} +} + +func (_c *InvoicesApi_GetInvoice_Call) Run(run func(ctx context.Context, orgId string, invoiceId string)) *InvoicesApi_GetInvoice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *InvoicesApi_GetInvoice_Call) Return(_a0 admin.GetInvoiceApiRequest) *InvoicesApi_GetInvoice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_GetInvoice_Call) RunAndReturn(run func(context.Context, string, string) admin.GetInvoiceApiRequest) *InvoicesApi_GetInvoice_Call { + _c.Call.Return(run) + return _c +} + +// GetInvoiceExecute provides a mock function with given fields: r +func (_m *InvoicesApi) GetInvoiceExecute(r admin.GetInvoiceApiRequest) (string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetInvoiceExecute") + } + + var r0 string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetInvoiceApiRequest) (string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetInvoiceApiRequest) string); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(admin.GetInvoiceApiRequest) *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.GetInvoiceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_GetInvoiceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInvoiceExecute' +type InvoicesApi_GetInvoiceExecute_Call struct { + *mock.Call +} + +// GetInvoiceExecute is a helper method to define mock.On call +// - r admin.GetInvoiceApiRequest +func (_e *InvoicesApi_Expecter) GetInvoiceExecute(r interface{}) *InvoicesApi_GetInvoiceExecute_Call { + return &InvoicesApi_GetInvoiceExecute_Call{Call: _e.mock.On("GetInvoiceExecute", r)} +} + +func (_c *InvoicesApi_GetInvoiceExecute_Call) Run(run func(r admin.GetInvoiceApiRequest)) *InvoicesApi_GetInvoiceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetInvoiceApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_GetInvoiceExecute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *InvoicesApi_GetInvoiceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_GetInvoiceExecute_Call) RunAndReturn(run func(admin.GetInvoiceApiRequest) (string, *http.Response, error)) *InvoicesApi_GetInvoiceExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetInvoiceWithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) GetInvoiceWithParams(ctx context.Context, args *admin.GetInvoiceApiParams) admin.GetInvoiceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetInvoiceWithParams") + } + + var r0 admin.GetInvoiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetInvoiceApiParams) admin.GetInvoiceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetInvoiceApiRequest) + } + + return r0 +} + +// InvoicesApi_GetInvoiceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInvoiceWithParams' +type InvoicesApi_GetInvoiceWithParams_Call struct { + *mock.Call +} + +// GetInvoiceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetInvoiceApiParams +func (_e *InvoicesApi_Expecter) GetInvoiceWithParams(ctx interface{}, args interface{}) *InvoicesApi_GetInvoiceWithParams_Call { + return &InvoicesApi_GetInvoiceWithParams_Call{Call: _e.mock.On("GetInvoiceWithParams", ctx, args)} +} + +func (_c *InvoicesApi_GetInvoiceWithParams_Call) Run(run func(ctx context.Context, args *admin.GetInvoiceApiParams)) *InvoicesApi_GetInvoiceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetInvoiceApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_GetInvoiceWithParams_Call) Return(_a0 admin.GetInvoiceApiRequest) *InvoicesApi_GetInvoiceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_GetInvoiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetInvoiceApiParams) admin.GetInvoiceApiRequest) *InvoicesApi_GetInvoiceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListInvoices provides a mock function with given fields: ctx, orgId +func (_m *InvoicesApi) ListInvoices(ctx context.Context, orgId string) admin.ListInvoicesApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListInvoices") + } + + var r0 admin.ListInvoicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListInvoicesApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListInvoicesApiRequest) + } + + return r0 +} + +// InvoicesApi_ListInvoices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInvoices' +type InvoicesApi_ListInvoices_Call struct { + *mock.Call +} + +// ListInvoices is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *InvoicesApi_Expecter) ListInvoices(ctx interface{}, orgId interface{}) *InvoicesApi_ListInvoices_Call { + return &InvoicesApi_ListInvoices_Call{Call: _e.mock.On("ListInvoices", ctx, orgId)} +} + +func (_c *InvoicesApi_ListInvoices_Call) Run(run func(ctx context.Context, orgId string)) *InvoicesApi_ListInvoices_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *InvoicesApi_ListInvoices_Call) Return(_a0 admin.ListInvoicesApiRequest) *InvoicesApi_ListInvoices_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_ListInvoices_Call) RunAndReturn(run func(context.Context, string) admin.ListInvoicesApiRequest) *InvoicesApi_ListInvoices_Call { + _c.Call.Return(run) + return _c +} + +// ListInvoicesExecute provides a mock function with given fields: r +func (_m *InvoicesApi) ListInvoicesExecute(r admin.ListInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListInvoicesExecute") + } + + var r0 *admin.PaginatedApiInvoice + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListInvoicesApiRequest) *admin.PaginatedApiInvoice); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiInvoice) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListInvoicesApiRequest) *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.ListInvoicesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_ListInvoicesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInvoicesExecute' +type InvoicesApi_ListInvoicesExecute_Call struct { + *mock.Call +} + +// ListInvoicesExecute is a helper method to define mock.On call +// - r admin.ListInvoicesApiRequest +func (_e *InvoicesApi_Expecter) ListInvoicesExecute(r interface{}) *InvoicesApi_ListInvoicesExecute_Call { + return &InvoicesApi_ListInvoicesExecute_Call{Call: _e.mock.On("ListInvoicesExecute", r)} +} + +func (_c *InvoicesApi_ListInvoicesExecute_Call) Run(run func(r admin.ListInvoicesApiRequest)) *InvoicesApi_ListInvoicesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListInvoicesApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_ListInvoicesExecute_Call) Return(_a0 *admin.PaginatedApiInvoice, _a1 *http.Response, _a2 error) *InvoicesApi_ListInvoicesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_ListInvoicesExecute_Call) RunAndReturn(run func(admin.ListInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error)) *InvoicesApi_ListInvoicesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListInvoicesWithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) ListInvoicesWithParams(ctx context.Context, args *admin.ListInvoicesApiParams) admin.ListInvoicesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListInvoicesWithParams") + } + + var r0 admin.ListInvoicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListInvoicesApiParams) admin.ListInvoicesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListInvoicesApiRequest) + } + + return r0 +} + +// InvoicesApi_ListInvoicesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInvoicesWithParams' +type InvoicesApi_ListInvoicesWithParams_Call struct { + *mock.Call +} + +// ListInvoicesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListInvoicesApiParams +func (_e *InvoicesApi_Expecter) ListInvoicesWithParams(ctx interface{}, args interface{}) *InvoicesApi_ListInvoicesWithParams_Call { + return &InvoicesApi_ListInvoicesWithParams_Call{Call: _e.mock.On("ListInvoicesWithParams", ctx, args)} +} + +func (_c *InvoicesApi_ListInvoicesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListInvoicesApiParams)) *InvoicesApi_ListInvoicesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListInvoicesApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_ListInvoicesWithParams_Call) Return(_a0 admin.ListInvoicesApiRequest) *InvoicesApi_ListInvoicesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_ListInvoicesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListInvoicesApiParams) admin.ListInvoicesApiRequest) *InvoicesApi_ListInvoicesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPendingInvoices provides a mock function with given fields: ctx, orgId +func (_m *InvoicesApi) ListPendingInvoices(ctx context.Context, orgId string) admin.ListPendingInvoicesApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListPendingInvoices") + } + + var r0 admin.ListPendingInvoicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListPendingInvoicesApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListPendingInvoicesApiRequest) + } + + return r0 +} + +// InvoicesApi_ListPendingInvoices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPendingInvoices' +type InvoicesApi_ListPendingInvoices_Call struct { + *mock.Call +} + +// ListPendingInvoices is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *InvoicesApi_Expecter) ListPendingInvoices(ctx interface{}, orgId interface{}) *InvoicesApi_ListPendingInvoices_Call { + return &InvoicesApi_ListPendingInvoices_Call{Call: _e.mock.On("ListPendingInvoices", ctx, orgId)} +} + +func (_c *InvoicesApi_ListPendingInvoices_Call) Run(run func(ctx context.Context, orgId string)) *InvoicesApi_ListPendingInvoices_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoices_Call) Return(_a0 admin.ListPendingInvoicesApiRequest) *InvoicesApi_ListPendingInvoices_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoices_Call) RunAndReturn(run func(context.Context, string) admin.ListPendingInvoicesApiRequest) *InvoicesApi_ListPendingInvoices_Call { + _c.Call.Return(run) + return _c +} + +// ListPendingInvoicesExecute provides a mock function with given fields: r +func (_m *InvoicesApi) ListPendingInvoicesExecute(r admin.ListPendingInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPendingInvoicesExecute") + } + + var r0 *admin.PaginatedApiInvoice + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPendingInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPendingInvoicesApiRequest) *admin.PaginatedApiInvoice); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiInvoice) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPendingInvoicesApiRequest) *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.ListPendingInvoicesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// InvoicesApi_ListPendingInvoicesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPendingInvoicesExecute' +type InvoicesApi_ListPendingInvoicesExecute_Call struct { + *mock.Call +} + +// ListPendingInvoicesExecute is a helper method to define mock.On call +// - r admin.ListPendingInvoicesApiRequest +func (_e *InvoicesApi_Expecter) ListPendingInvoicesExecute(r interface{}) *InvoicesApi_ListPendingInvoicesExecute_Call { + return &InvoicesApi_ListPendingInvoicesExecute_Call{Call: _e.mock.On("ListPendingInvoicesExecute", r)} +} + +func (_c *InvoicesApi_ListPendingInvoicesExecute_Call) Run(run func(r admin.ListPendingInvoicesApiRequest)) *InvoicesApi_ListPendingInvoicesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPendingInvoicesApiRequest)) + }) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoicesExecute_Call) Return(_a0 *admin.PaginatedApiInvoice, _a1 *http.Response, _a2 error) *InvoicesApi_ListPendingInvoicesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoicesExecute_Call) RunAndReturn(run func(admin.ListPendingInvoicesApiRequest) (*admin.PaginatedApiInvoice, *http.Response, error)) *InvoicesApi_ListPendingInvoicesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPendingInvoicesWithParams provides a mock function with given fields: ctx, args +func (_m *InvoicesApi) ListPendingInvoicesWithParams(ctx context.Context, args *admin.ListPendingInvoicesApiParams) admin.ListPendingInvoicesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPendingInvoicesWithParams") + } + + var r0 admin.ListPendingInvoicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPendingInvoicesApiParams) admin.ListPendingInvoicesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPendingInvoicesApiRequest) + } + + return r0 +} + +// InvoicesApi_ListPendingInvoicesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPendingInvoicesWithParams' +type InvoicesApi_ListPendingInvoicesWithParams_Call struct { + *mock.Call +} + +// ListPendingInvoicesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPendingInvoicesApiParams +func (_e *InvoicesApi_Expecter) ListPendingInvoicesWithParams(ctx interface{}, args interface{}) *InvoicesApi_ListPendingInvoicesWithParams_Call { + return &InvoicesApi_ListPendingInvoicesWithParams_Call{Call: _e.mock.On("ListPendingInvoicesWithParams", ctx, args)} +} + +func (_c *InvoicesApi_ListPendingInvoicesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPendingInvoicesApiParams)) *InvoicesApi_ListPendingInvoicesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPendingInvoicesApiParams)) + }) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoicesWithParams_Call) Return(_a0 admin.ListPendingInvoicesApiRequest) *InvoicesApi_ListPendingInvoicesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *InvoicesApi_ListPendingInvoicesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPendingInvoicesApiParams) admin.ListPendingInvoicesApiRequest) *InvoicesApi_ListPendingInvoicesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewInvoicesApi creates a new instance of InvoicesApi. 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 NewInvoicesApi(t interface { + mock.TestingT + Cleanup(func()) +}) *InvoicesApi { + mock := &InvoicesApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/ldap_configuration_api.go b/mockadmin/ldap_configuration_api.go new file mode 100644 index 000000000..67fbd7f7b --- /dev/null +++ b/mockadmin/ldap_configuration_api.go @@ -0,0 +1,848 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// LDAPConfigurationApi is an autogenerated mock type for the LDAPConfigurationApi type +type LDAPConfigurationApi struct { + mock.Mock +} + +type LDAPConfigurationApi_Expecter struct { + mock *mock.Mock +} + +func (_m *LDAPConfigurationApi) EXPECT() *LDAPConfigurationApi_Expecter { + return &LDAPConfigurationApi_Expecter{mock: &_m.Mock} +} + +// DeleteLDAPConfiguration provides a mock function with given fields: ctx, groupId +func (_m *LDAPConfigurationApi) DeleteLDAPConfiguration(ctx context.Context, groupId string) admin.DeleteLDAPConfigurationApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for DeleteLDAPConfiguration") + } + + var r0 admin.DeleteLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.DeleteLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_DeleteLDAPConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLDAPConfiguration' +type LDAPConfigurationApi_DeleteLDAPConfiguration_Call struct { + *mock.Call +} + +// DeleteLDAPConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *LDAPConfigurationApi_Expecter) DeleteLDAPConfiguration(ctx interface{}, groupId interface{}) *LDAPConfigurationApi_DeleteLDAPConfiguration_Call { + return &LDAPConfigurationApi_DeleteLDAPConfiguration_Call{Call: _e.mock.On("DeleteLDAPConfiguration", ctx, groupId)} +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfiguration_Call) Run(run func(ctx context.Context, groupId string)) *LDAPConfigurationApi_DeleteLDAPConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfiguration_Call) Return(_a0 admin.DeleteLDAPConfigurationApiRequest) *LDAPConfigurationApi_DeleteLDAPConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfiguration_Call) RunAndReturn(run func(context.Context, string) admin.DeleteLDAPConfigurationApiRequest) *LDAPConfigurationApi_DeleteLDAPConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLDAPConfigurationExecute provides a mock function with given fields: r +func (_m *LDAPConfigurationApi) DeleteLDAPConfigurationExecute(r admin.DeleteLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteLDAPConfigurationExecute") + } + + var r0 *admin.UserSecurity + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteLDAPConfigurationApiRequest) *admin.UserSecurity); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserSecurity) + } + } + + if rf, ok := ret.Get(1).(func(admin.DeleteLDAPConfigurationApiRequest) *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.DeleteLDAPConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLDAPConfigurationExecute' +type LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call struct { + *mock.Call +} + +// DeleteLDAPConfigurationExecute is a helper method to define mock.On call +// - r admin.DeleteLDAPConfigurationApiRequest +func (_e *LDAPConfigurationApi_Expecter) DeleteLDAPConfigurationExecute(r interface{}) *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call { + return &LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call{Call: _e.mock.On("DeleteLDAPConfigurationExecute", r)} +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call) Run(run func(r admin.DeleteLDAPConfigurationApiRequest)) *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteLDAPConfigurationApiRequest)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call) Return(_a0 *admin.UserSecurity, _a1 *http.Response, _a2 error) *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call) RunAndReturn(run func(admin.DeleteLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)) *LDAPConfigurationApi_DeleteLDAPConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLDAPConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *LDAPConfigurationApi) DeleteLDAPConfigurationWithParams(ctx context.Context, args *admin.DeleteLDAPConfigurationApiParams) admin.DeleteLDAPConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteLDAPConfigurationWithParams") + } + + var r0 admin.DeleteLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteLDAPConfigurationApiParams) admin.DeleteLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLDAPConfigurationWithParams' +type LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call struct { + *mock.Call +} + +// DeleteLDAPConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteLDAPConfigurationApiParams +func (_e *LDAPConfigurationApi_Expecter) DeleteLDAPConfigurationWithParams(ctx interface{}, args interface{}) *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call { + return &LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call{Call: _e.mock.On("DeleteLDAPConfigurationWithParams", ctx, args)} +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteLDAPConfigurationApiParams)) *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteLDAPConfigurationApiParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call) Return(_a0 admin.DeleteLDAPConfigurationApiRequest) *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteLDAPConfigurationApiParams) admin.DeleteLDAPConfigurationApiRequest) *LDAPConfigurationApi_DeleteLDAPConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfiguration provides a mock function with given fields: ctx, groupId +func (_m *LDAPConfigurationApi) GetLDAPConfiguration(ctx context.Context, groupId string) admin.GetLDAPConfigurationApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfiguration") + } + + var r0 admin.GetLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_GetLDAPConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfiguration' +type LDAPConfigurationApi_GetLDAPConfiguration_Call struct { + *mock.Call +} + +// GetLDAPConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfiguration(ctx interface{}, groupId interface{}) *LDAPConfigurationApi_GetLDAPConfiguration_Call { + return &LDAPConfigurationApi_GetLDAPConfiguration_Call{Call: _e.mock.On("GetLDAPConfiguration", ctx, groupId)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfiguration_Call) Run(run func(ctx context.Context, groupId string)) *LDAPConfigurationApi_GetLDAPConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfiguration_Call) Return(_a0 admin.GetLDAPConfigurationApiRequest) *LDAPConfigurationApi_GetLDAPConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfiguration_Call) RunAndReturn(run func(context.Context, string) admin.GetLDAPConfigurationApiRequest) *LDAPConfigurationApi_GetLDAPConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfigurationExecute provides a mock function with given fields: r +func (_m *LDAPConfigurationApi) GetLDAPConfigurationExecute(r admin.GetLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfigurationExecute") + } + + var r0 *admin.UserSecurity + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLDAPConfigurationApiRequest) *admin.UserSecurity); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserSecurity) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLDAPConfigurationApiRequest) *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.GetLDAPConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LDAPConfigurationApi_GetLDAPConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfigurationExecute' +type LDAPConfigurationApi_GetLDAPConfigurationExecute_Call struct { + *mock.Call +} + +// GetLDAPConfigurationExecute is a helper method to define mock.On call +// - r admin.GetLDAPConfigurationApiRequest +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfigurationExecute(r interface{}) *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call { + return &LDAPConfigurationApi_GetLDAPConfigurationExecute_Call{Call: _e.mock.On("GetLDAPConfigurationExecute", r)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call) Run(run func(r admin.GetLDAPConfigurationApiRequest)) *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLDAPConfigurationApiRequest)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call) Return(_a0 *admin.UserSecurity, _a1 *http.Response, _a2 error) *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call) RunAndReturn(run func(admin.GetLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)) *LDAPConfigurationApi_GetLDAPConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfigurationStatus provides a mock function with given fields: ctx, groupId, requestId +func (_m *LDAPConfigurationApi) GetLDAPConfigurationStatus(ctx context.Context, groupId string, requestId string) admin.GetLDAPConfigurationStatusApiRequest { + ret := _m.Called(ctx, groupId, requestId) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfigurationStatus") + } + + var r0 admin.GetLDAPConfigurationStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetLDAPConfigurationStatusApiRequest); ok { + r0 = rf(ctx, groupId, requestId) + } else { + r0 = ret.Get(0).(admin.GetLDAPConfigurationStatusApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_GetLDAPConfigurationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfigurationStatus' +type LDAPConfigurationApi_GetLDAPConfigurationStatus_Call struct { + *mock.Call +} + +// GetLDAPConfigurationStatus is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - requestId string +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfigurationStatus(ctx interface{}, groupId interface{}, requestId interface{}) *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call { + return &LDAPConfigurationApi_GetLDAPConfigurationStatus_Call{Call: _e.mock.On("GetLDAPConfigurationStatus", ctx, groupId, requestId)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call) Run(run func(ctx context.Context, groupId string, requestId string)) *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call) Return(_a0 admin.GetLDAPConfigurationStatusApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetLDAPConfigurationStatusApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfigurationStatusExecute provides a mock function with given fields: r +func (_m *LDAPConfigurationApi) GetLDAPConfigurationStatusExecute(r admin.GetLDAPConfigurationStatusApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfigurationStatusExecute") + } + + var r0 *admin.LDAPVerifyConnectivityJobRequest + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLDAPConfigurationStatusApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLDAPConfigurationStatusApiRequest) *admin.LDAPVerifyConnectivityJobRequest); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LDAPVerifyConnectivityJobRequest) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLDAPConfigurationStatusApiRequest) *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.GetLDAPConfigurationStatusApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfigurationStatusExecute' +type LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call struct { + *mock.Call +} + +// GetLDAPConfigurationStatusExecute is a helper method to define mock.On call +// - r admin.GetLDAPConfigurationStatusApiRequest +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfigurationStatusExecute(r interface{}) *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call { + return &LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call{Call: _e.mock.On("GetLDAPConfigurationStatusExecute", r)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call) Run(run func(r admin.GetLDAPConfigurationStatusApiRequest)) *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLDAPConfigurationStatusApiRequest)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call) Return(_a0 *admin.LDAPVerifyConnectivityJobRequest, _a1 *http.Response, _a2 error) *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call) RunAndReturn(run func(admin.GetLDAPConfigurationStatusApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error)) *LDAPConfigurationApi_GetLDAPConfigurationStatusExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfigurationStatusWithParams provides a mock function with given fields: ctx, args +func (_m *LDAPConfigurationApi) GetLDAPConfigurationStatusWithParams(ctx context.Context, args *admin.GetLDAPConfigurationStatusApiParams) admin.GetLDAPConfigurationStatusApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfigurationStatusWithParams") + } + + var r0 admin.GetLDAPConfigurationStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLDAPConfigurationStatusApiParams) admin.GetLDAPConfigurationStatusApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLDAPConfigurationStatusApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfigurationStatusWithParams' +type LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call struct { + *mock.Call +} + +// GetLDAPConfigurationStatusWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLDAPConfigurationStatusApiParams +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfigurationStatusWithParams(ctx interface{}, args interface{}) *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call { + return &LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call{Call: _e.mock.On("GetLDAPConfigurationStatusWithParams", ctx, args)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLDAPConfigurationStatusApiParams)) *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLDAPConfigurationStatusApiParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call) Return(_a0 admin.GetLDAPConfigurationStatusApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLDAPConfigurationStatusApiParams) admin.GetLDAPConfigurationStatusApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationStatusWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLDAPConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *LDAPConfigurationApi) GetLDAPConfigurationWithParams(ctx context.Context, args *admin.GetLDAPConfigurationApiParams) admin.GetLDAPConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLDAPConfigurationWithParams") + } + + var r0 admin.GetLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLDAPConfigurationApiParams) admin.GetLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLDAPConfigurationWithParams' +type LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call struct { + *mock.Call +} + +// GetLDAPConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLDAPConfigurationApiParams +func (_e *LDAPConfigurationApi_Expecter) GetLDAPConfigurationWithParams(ctx interface{}, args interface{}) *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call { + return &LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call{Call: _e.mock.On("GetLDAPConfigurationWithParams", ctx, args)} +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLDAPConfigurationApiParams)) *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLDAPConfigurationApiParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call) Return(_a0 admin.GetLDAPConfigurationApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLDAPConfigurationApiParams) admin.GetLDAPConfigurationApiRequest) *LDAPConfigurationApi_GetLDAPConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// SaveLDAPConfiguration provides a mock function with given fields: ctx, groupId, userSecurity +func (_m *LDAPConfigurationApi) SaveLDAPConfiguration(ctx context.Context, groupId string, userSecurity *admin.UserSecurity) admin.SaveLDAPConfigurationApiRequest { + ret := _m.Called(ctx, groupId, userSecurity) + + if len(ret) == 0 { + panic("no return value specified for SaveLDAPConfiguration") + } + + var r0 admin.SaveLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.UserSecurity) admin.SaveLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, userSecurity) + } else { + r0 = ret.Get(0).(admin.SaveLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_SaveLDAPConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveLDAPConfiguration' +type LDAPConfigurationApi_SaveLDAPConfiguration_Call struct { + *mock.Call +} + +// SaveLDAPConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - userSecurity *admin.UserSecurity +func (_e *LDAPConfigurationApi_Expecter) SaveLDAPConfiguration(ctx interface{}, groupId interface{}, userSecurity interface{}) *LDAPConfigurationApi_SaveLDAPConfiguration_Call { + return &LDAPConfigurationApi_SaveLDAPConfiguration_Call{Call: _e.mock.On("SaveLDAPConfiguration", ctx, groupId, userSecurity)} +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfiguration_Call) Run(run func(ctx context.Context, groupId string, userSecurity *admin.UserSecurity)) *LDAPConfigurationApi_SaveLDAPConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.UserSecurity)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfiguration_Call) Return(_a0 admin.SaveLDAPConfigurationApiRequest) *LDAPConfigurationApi_SaveLDAPConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.UserSecurity) admin.SaveLDAPConfigurationApiRequest) *LDAPConfigurationApi_SaveLDAPConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// SaveLDAPConfigurationExecute provides a mock function with given fields: r +func (_m *LDAPConfigurationApi) SaveLDAPConfigurationExecute(r admin.SaveLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for SaveLDAPConfigurationExecute") + } + + var r0 *admin.UserSecurity + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.SaveLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.SaveLDAPConfigurationApiRequest) *admin.UserSecurity); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserSecurity) + } + } + + if rf, ok := ret.Get(1).(func(admin.SaveLDAPConfigurationApiRequest) *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.SaveLDAPConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveLDAPConfigurationExecute' +type LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call struct { + *mock.Call +} + +// SaveLDAPConfigurationExecute is a helper method to define mock.On call +// - r admin.SaveLDAPConfigurationApiRequest +func (_e *LDAPConfigurationApi_Expecter) SaveLDAPConfigurationExecute(r interface{}) *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call { + return &LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call{Call: _e.mock.On("SaveLDAPConfigurationExecute", r)} +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call) Run(run func(r admin.SaveLDAPConfigurationApiRequest)) *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.SaveLDAPConfigurationApiRequest)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call) Return(_a0 *admin.UserSecurity, _a1 *http.Response, _a2 error) *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call) RunAndReturn(run func(admin.SaveLDAPConfigurationApiRequest) (*admin.UserSecurity, *http.Response, error)) *LDAPConfigurationApi_SaveLDAPConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// SaveLDAPConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *LDAPConfigurationApi) SaveLDAPConfigurationWithParams(ctx context.Context, args *admin.SaveLDAPConfigurationApiParams) admin.SaveLDAPConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for SaveLDAPConfigurationWithParams") + } + + var r0 admin.SaveLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.SaveLDAPConfigurationApiParams) admin.SaveLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.SaveLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveLDAPConfigurationWithParams' +type LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call struct { + *mock.Call +} + +// SaveLDAPConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.SaveLDAPConfigurationApiParams +func (_e *LDAPConfigurationApi_Expecter) SaveLDAPConfigurationWithParams(ctx interface{}, args interface{}) *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call { + return &LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call{Call: _e.mock.On("SaveLDAPConfigurationWithParams", ctx, args)} +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.SaveLDAPConfigurationApiParams)) *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.SaveLDAPConfigurationApiParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call) Return(_a0 admin.SaveLDAPConfigurationApiRequest) *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.SaveLDAPConfigurationApiParams) admin.SaveLDAPConfigurationApiRequest) *LDAPConfigurationApi_SaveLDAPConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// VerifyLDAPConfiguration provides a mock function with given fields: ctx, groupId, lDAPVerifyConnectivityJobRequestParams +func (_m *LDAPConfigurationApi) VerifyLDAPConfiguration(ctx context.Context, groupId string, lDAPVerifyConnectivityJobRequestParams *admin.LDAPVerifyConnectivityJobRequestParams) admin.VerifyLDAPConfigurationApiRequest { + ret := _m.Called(ctx, groupId, lDAPVerifyConnectivityJobRequestParams) + + if len(ret) == 0 { + panic("no return value specified for VerifyLDAPConfiguration") + } + + var r0 admin.VerifyLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LDAPVerifyConnectivityJobRequestParams) admin.VerifyLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, lDAPVerifyConnectivityJobRequestParams) + } else { + r0 = ret.Get(0).(admin.VerifyLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_VerifyLDAPConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyLDAPConfiguration' +type LDAPConfigurationApi_VerifyLDAPConfiguration_Call struct { + *mock.Call +} + +// VerifyLDAPConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - lDAPVerifyConnectivityJobRequestParams *admin.LDAPVerifyConnectivityJobRequestParams +func (_e *LDAPConfigurationApi_Expecter) VerifyLDAPConfiguration(ctx interface{}, groupId interface{}, lDAPVerifyConnectivityJobRequestParams interface{}) *LDAPConfigurationApi_VerifyLDAPConfiguration_Call { + return &LDAPConfigurationApi_VerifyLDAPConfiguration_Call{Call: _e.mock.On("VerifyLDAPConfiguration", ctx, groupId, lDAPVerifyConnectivityJobRequestParams)} +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfiguration_Call) Run(run func(ctx context.Context, groupId string, lDAPVerifyConnectivityJobRequestParams *admin.LDAPVerifyConnectivityJobRequestParams)) *LDAPConfigurationApi_VerifyLDAPConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.LDAPVerifyConnectivityJobRequestParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfiguration_Call) Return(_a0 admin.VerifyLDAPConfigurationApiRequest) *LDAPConfigurationApi_VerifyLDAPConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.LDAPVerifyConnectivityJobRequestParams) admin.VerifyLDAPConfigurationApiRequest) *LDAPConfigurationApi_VerifyLDAPConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// VerifyLDAPConfigurationExecute provides a mock function with given fields: r +func (_m *LDAPConfigurationApi) VerifyLDAPConfigurationExecute(r admin.VerifyLDAPConfigurationApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for VerifyLDAPConfigurationExecute") + } + + var r0 *admin.LDAPVerifyConnectivityJobRequest + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.VerifyLDAPConfigurationApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.VerifyLDAPConfigurationApiRequest) *admin.LDAPVerifyConnectivityJobRequest); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.LDAPVerifyConnectivityJobRequest) + } + } + + if rf, ok := ret.Get(1).(func(admin.VerifyLDAPConfigurationApiRequest) *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.VerifyLDAPConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyLDAPConfigurationExecute' +type LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call struct { + *mock.Call +} + +// VerifyLDAPConfigurationExecute is a helper method to define mock.On call +// - r admin.VerifyLDAPConfigurationApiRequest +func (_e *LDAPConfigurationApi_Expecter) VerifyLDAPConfigurationExecute(r interface{}) *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call { + return &LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call{Call: _e.mock.On("VerifyLDAPConfigurationExecute", r)} +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call) Run(run func(r admin.VerifyLDAPConfigurationApiRequest)) *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.VerifyLDAPConfigurationApiRequest)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call) Return(_a0 *admin.LDAPVerifyConnectivityJobRequest, _a1 *http.Response, _a2 error) *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call) RunAndReturn(run func(admin.VerifyLDAPConfigurationApiRequest) (*admin.LDAPVerifyConnectivityJobRequest, *http.Response, error)) *LDAPConfigurationApi_VerifyLDAPConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// VerifyLDAPConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *LDAPConfigurationApi) VerifyLDAPConfigurationWithParams(ctx context.Context, args *admin.VerifyLDAPConfigurationApiParams) admin.VerifyLDAPConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for VerifyLDAPConfigurationWithParams") + } + + var r0 admin.VerifyLDAPConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.VerifyLDAPConfigurationApiParams) admin.VerifyLDAPConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.VerifyLDAPConfigurationApiRequest) + } + + return r0 +} + +// LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyLDAPConfigurationWithParams' +type LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call struct { + *mock.Call +} + +// VerifyLDAPConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.VerifyLDAPConfigurationApiParams +func (_e *LDAPConfigurationApi_Expecter) VerifyLDAPConfigurationWithParams(ctx interface{}, args interface{}) *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call { + return &LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call{Call: _e.mock.On("VerifyLDAPConfigurationWithParams", ctx, args)} +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.VerifyLDAPConfigurationApiParams)) *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.VerifyLDAPConfigurationApiParams)) + }) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call) Return(_a0 admin.VerifyLDAPConfigurationApiRequest) *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.VerifyLDAPConfigurationApiParams) admin.VerifyLDAPConfigurationApiRequest) *LDAPConfigurationApi_VerifyLDAPConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewLDAPConfigurationApi creates a new instance of LDAPConfigurationApi. 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 NewLDAPConfigurationApi(t interface { + mock.TestingT + Cleanup(func()) +}) *LDAPConfigurationApi { + mock := &LDAPConfigurationApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/legacy_backup_api.go b/mockadmin/legacy_backup_api.go new file mode 100644 index 000000000..628da0d84 --- /dev/null +++ b/mockadmin/legacy_backup_api.go @@ -0,0 +1,1667 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// LegacyBackupApi is an autogenerated mock type for the LegacyBackupApi type +type LegacyBackupApi struct { + mock.Mock +} + +type LegacyBackupApi_Expecter struct { + mock *mock.Mock +} + +func (_m *LegacyBackupApi) EXPECT() *LegacyBackupApi_Expecter { + return &LegacyBackupApi_Expecter{mock: &_m.Mock} +} + +// DeleteLegacySnapshot provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *LegacyBackupApi) DeleteLegacySnapshot(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.DeleteLegacySnapshotApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for DeleteLegacySnapshot") + } + + var r0 admin.DeleteLegacySnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteLegacySnapshotApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.DeleteLegacySnapshotApiRequest) + } + + return r0 +} + +// LegacyBackupApi_DeleteLegacySnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLegacySnapshot' +type LegacyBackupApi_DeleteLegacySnapshot_Call struct { + *mock.Call +} + +// DeleteLegacySnapshot is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *LegacyBackupApi_DeleteLegacySnapshot_Call { + return &LegacyBackupApi_DeleteLegacySnapshot_Call{Call: _e.mock.On("DeleteLegacySnapshot", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshot_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *LegacyBackupApi_DeleteLegacySnapshot_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 *LegacyBackupApi_DeleteLegacySnapshot_Call) Return(_a0 admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshot_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshot_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLegacySnapshotExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) DeleteLegacySnapshotExecute(r admin.DeleteLegacySnapshotApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteLegacySnapshotExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteLegacySnapshotApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteLegacySnapshotApiRequest) 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.DeleteLegacySnapshotApiRequest) *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.DeleteLegacySnapshotApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_DeleteLegacySnapshotExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLegacySnapshotExecute' +type LegacyBackupApi_DeleteLegacySnapshotExecute_Call struct { + *mock.Call +} + +// DeleteLegacySnapshotExecute is a helper method to define mock.On call +// - r admin.DeleteLegacySnapshotApiRequest +func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshotExecute(r interface{}) *LegacyBackupApi_DeleteLegacySnapshotExecute_Call { + return &LegacyBackupApi_DeleteLegacySnapshotExecute_Call{Call: _e.mock.On("DeleteLegacySnapshotExecute", r)} +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotExecute_Call) Run(run func(r admin.DeleteLegacySnapshotApiRequest)) *LegacyBackupApi_DeleteLegacySnapshotExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteLegacySnapshotApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *LegacyBackupApi_DeleteLegacySnapshotExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotExecute_Call) RunAndReturn(run func(admin.DeleteLegacySnapshotApiRequest) (map[string]interface{}, *http.Response, error)) *LegacyBackupApi_DeleteLegacySnapshotExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteLegacySnapshotWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) DeleteLegacySnapshotWithParams(ctx context.Context, args *admin.DeleteLegacySnapshotApiParams) admin.DeleteLegacySnapshotApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteLegacySnapshotWithParams") + } + + var r0 admin.DeleteLegacySnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteLegacySnapshotApiParams) admin.DeleteLegacySnapshotApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteLegacySnapshotApiRequest) + } + + return r0 +} + +// LegacyBackupApi_DeleteLegacySnapshotWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLegacySnapshotWithParams' +type LegacyBackupApi_DeleteLegacySnapshotWithParams_Call struct { + *mock.Call +} + +// DeleteLegacySnapshotWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteLegacySnapshotApiParams +func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshotWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call { + return &LegacyBackupApi_DeleteLegacySnapshotWithParams_Call{Call: _e.mock.On("DeleteLegacySnapshotWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteLegacySnapshotApiParams)) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteLegacySnapshotApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call) Return(_a0 admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteLegacySnapshotApiParams) admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupCheckpoint provides a mock function with given fields: ctx, groupId, checkpointId, clusterName +func (_m *LegacyBackupApi) GetLegacyBackupCheckpoint(ctx context.Context, groupId string, checkpointId string, clusterName string) admin.GetLegacyBackupCheckpointApiRequest { + ret := _m.Called(ctx, groupId, checkpointId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupCheckpoint") + } + + var r0 admin.GetLegacyBackupCheckpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetLegacyBackupCheckpointApiRequest); ok { + r0 = rf(ctx, groupId, checkpointId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetLegacyBackupCheckpointApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacyBackupCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupCheckpoint' +type LegacyBackupApi_GetLegacyBackupCheckpoint_Call struct { + *mock.Call +} + +// GetLegacyBackupCheckpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - checkpointId string +// - clusterName string +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpoint(ctx interface{}, groupId interface{}, checkpointId interface{}, clusterName interface{}) *LegacyBackupApi_GetLegacyBackupCheckpoint_Call { + return &LegacyBackupApi_GetLegacyBackupCheckpoint_Call{Call: _e.mock.On("GetLegacyBackupCheckpoint", ctx, groupId, checkpointId, clusterName)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpoint_Call) Run(run func(ctx context.Context, groupId string, checkpointId string, clusterName string)) *LegacyBackupApi_GetLegacyBackupCheckpoint_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 *LegacyBackupApi_GetLegacyBackupCheckpoint_Call) Return(_a0 admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpoint_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpoint_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupCheckpointExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) GetLegacyBackupCheckpointExecute(r admin.GetLegacyBackupCheckpointApiRequest) (*admin.ApiAtlasCheckpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupCheckpointExecute") + } + + var r0 *admin.ApiAtlasCheckpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLegacyBackupCheckpointApiRequest) (*admin.ApiAtlasCheckpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLegacyBackupCheckpointApiRequest) *admin.ApiAtlasCheckpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiAtlasCheckpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLegacyBackupCheckpointApiRequest) *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.GetLegacyBackupCheckpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupCheckpointExecute' +type LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call struct { + *mock.Call +} + +// GetLegacyBackupCheckpointExecute is a helper method to define mock.On call +// - r admin.GetLegacyBackupCheckpointApiRequest +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpointExecute(r interface{}) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call { + return &LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call{Call: _e.mock.On("GetLegacyBackupCheckpointExecute", r)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call) Run(run func(r admin.GetLegacyBackupCheckpointApiRequest)) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLegacyBackupCheckpointApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call) Return(_a0 *admin.ApiAtlasCheckpoint, _a1 *http.Response, _a2 error) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call) RunAndReturn(run func(admin.GetLegacyBackupCheckpointApiRequest) (*admin.ApiAtlasCheckpoint, *http.Response, error)) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupCheckpointWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) GetLegacyBackupCheckpointWithParams(ctx context.Context, args *admin.GetLegacyBackupCheckpointApiParams) admin.GetLegacyBackupCheckpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupCheckpointWithParams") + } + + var r0 admin.GetLegacyBackupCheckpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLegacyBackupCheckpointApiParams) admin.GetLegacyBackupCheckpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLegacyBackupCheckpointApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupCheckpointWithParams' +type LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call struct { + *mock.Call +} + +// GetLegacyBackupCheckpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLegacyBackupCheckpointApiParams +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpointWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call { + return &LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call{Call: _e.mock.On("GetLegacyBackupCheckpointWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLegacyBackupCheckpointApiParams)) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLegacyBackupCheckpointApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call) Return(_a0 admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacyBackupCheckpointApiParams) admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, jobId +func (_m *LegacyBackupApi) GetLegacyBackupRestoreJob(ctx context.Context, groupId string, clusterName string, jobId string) admin.GetLegacyBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, jobId) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupRestoreJob") + } + + var r0 admin.GetLegacyBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetLegacyBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, jobId) + } else { + r0 = ret.Get(0).(admin.GetLegacyBackupRestoreJobApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacyBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupRestoreJob' +type LegacyBackupApi_GetLegacyBackupRestoreJob_Call struct { + *mock.Call +} + +// GetLegacyBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - jobId string +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, jobId interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJob_Call { + return &LegacyBackupApi_GetLegacyBackupRestoreJob_Call{Call: _e.mock.On("GetLegacyBackupRestoreJob", ctx, groupId, clusterName, jobId)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, jobId string)) *LegacyBackupApi_GetLegacyBackupRestoreJob_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 *LegacyBackupApi_GetLegacyBackupRestoreJob_Call) Return(_a0 admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) GetLegacyBackupRestoreJobExecute(r admin.GetLegacyBackupRestoreJobApiRequest) (*admin.BackupRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupRestoreJobExecute") + } + + var r0 *admin.BackupRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLegacyBackupRestoreJobApiRequest) (*admin.BackupRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLegacyBackupRestoreJobApiRequest) *admin.BackupRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLegacyBackupRestoreJobApiRequest) *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.GetLegacyBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupRestoreJobExecute' +type LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// GetLegacyBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.GetLegacyBackupRestoreJobApiRequest +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJobExecute(r interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call { + return &LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call{Call: _e.mock.On("GetLegacyBackupRestoreJobExecute", r)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call) Run(run func(r admin.GetLegacyBackupRestoreJobApiRequest)) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLegacyBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call) Return(_a0 *admin.BackupRestoreJob, _a1 *http.Response, _a2 error) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetLegacyBackupRestoreJobApiRequest) (*admin.BackupRestoreJob, *http.Response, error)) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacyBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) GetLegacyBackupRestoreJobWithParams(ctx context.Context, args *admin.GetLegacyBackupRestoreJobApiParams) admin.GetLegacyBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLegacyBackupRestoreJobWithParams") + } + + var r0 admin.GetLegacyBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLegacyBackupRestoreJobApiParams) admin.GetLegacyBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLegacyBackupRestoreJobApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacyBackupRestoreJobWithParams' +type LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// GetLegacyBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLegacyBackupRestoreJobApiParams +func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJobWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call { + return &LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetLegacyBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLegacyBackupRestoreJobApiParams)) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLegacyBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call) Return(_a0 admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacyBackupRestoreJobApiParams) admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshot provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *LegacyBackupApi) GetLegacySnapshot(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetLegacySnapshotApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshot") + } + + var r0 admin.GetLegacySnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetLegacySnapshotApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.GetLegacySnapshotApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacySnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshot' +type LegacyBackupApi_GetLegacySnapshot_Call struct { + *mock.Call +} + +// GetLegacySnapshot is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *LegacyBackupApi_GetLegacySnapshot_Call { + return &LegacyBackupApi_GetLegacySnapshot_Call{Call: _e.mock.On("GetLegacySnapshot", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshot_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *LegacyBackupApi_GetLegacySnapshot_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 *LegacyBackupApi_GetLegacySnapshot_Call) Return(_a0 admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshot_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshot_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshot_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshotExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) GetLegacySnapshotExecute(r admin.GetLegacySnapshotApiRequest) (*admin.BackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshotExecute") + } + + var r0 *admin.BackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLegacySnapshotApiRequest) (*admin.BackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLegacySnapshotApiRequest) *admin.BackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLegacySnapshotApiRequest) *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.GetLegacySnapshotApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_GetLegacySnapshotExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshotExecute' +type LegacyBackupApi_GetLegacySnapshotExecute_Call struct { + *mock.Call +} + +// GetLegacySnapshotExecute is a helper method to define mock.On call +// - r admin.GetLegacySnapshotApiRequest +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotExecute(r interface{}) *LegacyBackupApi_GetLegacySnapshotExecute_Call { + return &LegacyBackupApi_GetLegacySnapshotExecute_Call{Call: _e.mock.On("GetLegacySnapshotExecute", r)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshotExecute_Call) Run(run func(r admin.GetLegacySnapshotApiRequest)) *LegacyBackupApi_GetLegacySnapshotExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLegacySnapshotApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotExecute_Call) Return(_a0 *admin.BackupSnapshot, _a1 *http.Response, _a2 error) *LegacyBackupApi_GetLegacySnapshotExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotExecute_Call) RunAndReturn(run func(admin.GetLegacySnapshotApiRequest) (*admin.BackupSnapshot, *http.Response, error)) *LegacyBackupApi_GetLegacySnapshotExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshotSchedule provides a mock function with given fields: ctx, groupId, clusterName +func (_m *LegacyBackupApi) GetLegacySnapshotSchedule(ctx context.Context, groupId string, clusterName string) admin.GetLegacySnapshotScheduleApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshotSchedule") + } + + var r0 admin.GetLegacySnapshotScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetLegacySnapshotScheduleApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetLegacySnapshotScheduleApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacySnapshotSchedule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshotSchedule' +type LegacyBackupApi_GetLegacySnapshotSchedule_Call struct { + *mock.Call +} + +// GetLegacySnapshotSchedule is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotSchedule(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_GetLegacySnapshotSchedule_Call { + return &LegacyBackupApi_GetLegacySnapshotSchedule_Call{Call: _e.mock.On("GetLegacySnapshotSchedule", ctx, groupId, clusterName)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshotSchedule_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *LegacyBackupApi_GetLegacySnapshotSchedule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotSchedule_Call) Return(_a0 admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotSchedule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotSchedule_Call) RunAndReturn(run func(context.Context, string, string) admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotSchedule_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshotScheduleExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) GetLegacySnapshotScheduleExecute(r admin.GetLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshotScheduleExecute") + } + + var r0 *admin.ApiAtlasSnapshotSchedule + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetLegacySnapshotScheduleApiRequest) *admin.ApiAtlasSnapshotSchedule); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiAtlasSnapshotSchedule) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetLegacySnapshotScheduleApiRequest) *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.GetLegacySnapshotScheduleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshotScheduleExecute' +type LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call struct { + *mock.Call +} + +// GetLegacySnapshotScheduleExecute is a helper method to define mock.On call +// - r admin.GetLegacySnapshotScheduleApiRequest +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotScheduleExecute(r interface{}) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call { + return &LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call{Call: _e.mock.On("GetLegacySnapshotScheduleExecute", r)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call) Run(run func(r admin.GetLegacySnapshotScheduleApiRequest)) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetLegacySnapshotScheduleApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call) Return(_a0 *admin.ApiAtlasSnapshotSchedule, _a1 *http.Response, _a2 error) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call) RunAndReturn(run func(admin.GetLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshotScheduleWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) GetLegacySnapshotScheduleWithParams(ctx context.Context, args *admin.GetLegacySnapshotScheduleApiParams) admin.GetLegacySnapshotScheduleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshotScheduleWithParams") + } + + var r0 admin.GetLegacySnapshotScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLegacySnapshotScheduleApiParams) admin.GetLegacySnapshotScheduleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLegacySnapshotScheduleApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshotScheduleWithParams' +type LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call struct { + *mock.Call +} + +// GetLegacySnapshotScheduleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLegacySnapshotScheduleApiParams +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotScheduleWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call { + return &LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call{Call: _e.mock.On("GetLegacySnapshotScheduleWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLegacySnapshotScheduleApiParams)) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLegacySnapshotScheduleApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call) Return(_a0 admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacySnapshotScheduleApiParams) admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetLegacySnapshotWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) GetLegacySnapshotWithParams(ctx context.Context, args *admin.GetLegacySnapshotApiParams) admin.GetLegacySnapshotApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetLegacySnapshotWithParams") + } + + var r0 admin.GetLegacySnapshotApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetLegacySnapshotApiParams) admin.GetLegacySnapshotApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetLegacySnapshotApiRequest) + } + + return r0 +} + +// LegacyBackupApi_GetLegacySnapshotWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLegacySnapshotWithParams' +type LegacyBackupApi_GetLegacySnapshotWithParams_Call struct { + *mock.Call +} + +// GetLegacySnapshotWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetLegacySnapshotApiParams +func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacySnapshotWithParams_Call { + return &LegacyBackupApi_GetLegacySnapshotWithParams_Call{Call: _e.mock.On("GetLegacySnapshotWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_GetLegacySnapshotWithParams_Call) Run(run func(ctx context.Context, args *admin.GetLegacySnapshotApiParams)) *LegacyBackupApi_GetLegacySnapshotWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetLegacySnapshotApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotWithParams_Call) Return(_a0 admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshotWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_GetLegacySnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacySnapshotApiParams) admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshotWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupCheckpoints provides a mock function with given fields: ctx, groupId, clusterName +func (_m *LegacyBackupApi) ListLegacyBackupCheckpoints(ctx context.Context, groupId string, clusterName string) admin.ListLegacyBackupCheckpointsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupCheckpoints") + } + + var r0 admin.ListLegacyBackupCheckpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListLegacyBackupCheckpointsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListLegacyBackupCheckpointsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacyBackupCheckpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupCheckpoints' +type LegacyBackupApi_ListLegacyBackupCheckpoints_Call struct { + *mock.Call +} + +// ListLegacyBackupCheckpoints is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpoints(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call { + return &LegacyBackupApi_ListLegacyBackupCheckpoints_Call{Call: _e.mock.On("ListLegacyBackupCheckpoints", ctx, groupId, clusterName)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpoints_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpoints_Call) Return(_a0 admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpoints_Call) RunAndReturn(run func(context.Context, string, string) admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupCheckpointsExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) ListLegacyBackupCheckpointsExecute(r admin.ListLegacyBackupCheckpointsApiRequest) (*admin.PaginatedApiAtlasCheckpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupCheckpointsExecute") + } + + var r0 *admin.PaginatedApiAtlasCheckpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListLegacyBackupCheckpointsApiRequest) (*admin.PaginatedApiAtlasCheckpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListLegacyBackupCheckpointsApiRequest) *admin.PaginatedApiAtlasCheckpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiAtlasCheckpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListLegacyBackupCheckpointsApiRequest) *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.ListLegacyBackupCheckpointsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupCheckpointsExecute' +type LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call struct { + *mock.Call +} + +// ListLegacyBackupCheckpointsExecute is a helper method to define mock.On call +// - r admin.ListLegacyBackupCheckpointsApiRequest +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpointsExecute(r interface{}) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call { + return &LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call{Call: _e.mock.On("ListLegacyBackupCheckpointsExecute", r)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call) Run(run func(r admin.ListLegacyBackupCheckpointsApiRequest)) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListLegacyBackupCheckpointsApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call) Return(_a0 *admin.PaginatedApiAtlasCheckpoint, _a1 *http.Response, _a2 error) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call) RunAndReturn(run func(admin.ListLegacyBackupCheckpointsApiRequest) (*admin.PaginatedApiAtlasCheckpoint, *http.Response, error)) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupCheckpointsWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) ListLegacyBackupCheckpointsWithParams(ctx context.Context, args *admin.ListLegacyBackupCheckpointsApiParams) admin.ListLegacyBackupCheckpointsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupCheckpointsWithParams") + } + + var r0 admin.ListLegacyBackupCheckpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListLegacyBackupCheckpointsApiParams) admin.ListLegacyBackupCheckpointsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListLegacyBackupCheckpointsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupCheckpointsWithParams' +type LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call struct { + *mock.Call +} + +// ListLegacyBackupCheckpointsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListLegacyBackupCheckpointsApiParams +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpointsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call { + return &LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call{Call: _e.mock.On("ListLegacyBackupCheckpointsWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListLegacyBackupCheckpointsApiParams)) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListLegacyBackupCheckpointsApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call) Return(_a0 admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacyBackupCheckpointsApiParams) admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupRestoreJobs provides a mock function with given fields: ctx, groupId, clusterName +func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobs(ctx context.Context, groupId string, clusterName string) admin.ListLegacyBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupRestoreJobs") + } + + var r0 admin.ListLegacyBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListLegacyBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListLegacyBackupRestoreJobsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacyBackupRestoreJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupRestoreJobs' +type LegacyBackupApi_ListLegacyBackupRestoreJobs_Call struct { + *mock.Call +} + +// ListLegacyBackupRestoreJobs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobs(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call { + return &LegacyBackupApi_ListLegacyBackupRestoreJobs_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobs", ctx, groupId, clusterName)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call) Return(_a0 admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call) RunAndReturn(run func(context.Context, string, string) admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupRestoreJobsExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobsExecute(r admin.ListLegacyBackupRestoreJobsApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupRestoreJobsExecute") + } + + var r0 *admin.PaginatedRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListLegacyBackupRestoreJobsApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListLegacyBackupRestoreJobsApiRequest) *admin.PaginatedRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListLegacyBackupRestoreJobsApiRequest) *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.ListLegacyBackupRestoreJobsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupRestoreJobsExecute' +type LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call struct { + *mock.Call +} + +// ListLegacyBackupRestoreJobsExecute is a helper method to define mock.On call +// - r admin.ListLegacyBackupRestoreJobsApiRequest +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobsExecute(r interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call { + return &LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobsExecute", r)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call) Run(run func(r admin.ListLegacyBackupRestoreJobsApiRequest)) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListLegacyBackupRestoreJobsApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call) Return(_a0 *admin.PaginatedRestoreJob, _a1 *http.Response, _a2 error) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListLegacyBackupRestoreJobsApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error)) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacyBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListLegacyBackupRestoreJobsApiParams) admin.ListLegacyBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListLegacyBackupRestoreJobsWithParams") + } + + var r0 admin.ListLegacyBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListLegacyBackupRestoreJobsApiParams) admin.ListLegacyBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListLegacyBackupRestoreJobsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacyBackupRestoreJobsWithParams' +type LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call struct { + *mock.Call +} + +// ListLegacyBackupRestoreJobsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListLegacyBackupRestoreJobsApiParams +func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call { + return &LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobsWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListLegacyBackupRestoreJobsApiParams)) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListLegacyBackupRestoreJobsApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacyBackupRestoreJobsApiParams) admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacySnapshots provides a mock function with given fields: ctx, groupId, clusterName +func (_m *LegacyBackupApi) ListLegacySnapshots(ctx context.Context, groupId string, clusterName string) admin.ListLegacySnapshotsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListLegacySnapshots") + } + + var r0 admin.ListLegacySnapshotsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListLegacySnapshotsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListLegacySnapshotsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacySnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacySnapshots' +type LegacyBackupApi_ListLegacySnapshots_Call struct { + *mock.Call +} + +// ListLegacySnapshots is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *LegacyBackupApi_Expecter) ListLegacySnapshots(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacySnapshots_Call { + return &LegacyBackupApi_ListLegacySnapshots_Call{Call: _e.mock.On("ListLegacySnapshots", ctx, groupId, clusterName)} +} + +func (_c *LegacyBackupApi_ListLegacySnapshots_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *LegacyBackupApi_ListLegacySnapshots_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshots_Call) Return(_a0 admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshots_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshots_Call) RunAndReturn(run func(context.Context, string, string) admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshots_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacySnapshotsExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) ListLegacySnapshotsExecute(r admin.ListLegacySnapshotsApiRequest) (*admin.PaginatedSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListLegacySnapshotsExecute") + } + + var r0 *admin.PaginatedSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListLegacySnapshotsApiRequest) (*admin.PaginatedSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListLegacySnapshotsApiRequest) *admin.PaginatedSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListLegacySnapshotsApiRequest) *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.ListLegacySnapshotsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_ListLegacySnapshotsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacySnapshotsExecute' +type LegacyBackupApi_ListLegacySnapshotsExecute_Call struct { + *mock.Call +} + +// ListLegacySnapshotsExecute is a helper method to define mock.On call +// - r admin.ListLegacySnapshotsApiRequest +func (_e *LegacyBackupApi_Expecter) ListLegacySnapshotsExecute(r interface{}) *LegacyBackupApi_ListLegacySnapshotsExecute_Call { + return &LegacyBackupApi_ListLegacySnapshotsExecute_Call{Call: _e.mock.On("ListLegacySnapshotsExecute", r)} +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsExecute_Call) Run(run func(r admin.ListLegacySnapshotsApiRequest)) *LegacyBackupApi_ListLegacySnapshotsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListLegacySnapshotsApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsExecute_Call) Return(_a0 *admin.PaginatedSnapshot, _a1 *http.Response, _a2 error) *LegacyBackupApi_ListLegacySnapshotsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsExecute_Call) RunAndReturn(run func(admin.ListLegacySnapshotsApiRequest) (*admin.PaginatedSnapshot, *http.Response, error)) *LegacyBackupApi_ListLegacySnapshotsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListLegacySnapshotsWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) ListLegacySnapshotsWithParams(ctx context.Context, args *admin.ListLegacySnapshotsApiParams) admin.ListLegacySnapshotsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListLegacySnapshotsWithParams") + } + + var r0 admin.ListLegacySnapshotsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListLegacySnapshotsApiParams) admin.ListLegacySnapshotsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListLegacySnapshotsApiRequest) + } + + return r0 +} + +// LegacyBackupApi_ListLegacySnapshotsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLegacySnapshotsWithParams' +type LegacyBackupApi_ListLegacySnapshotsWithParams_Call struct { + *mock.Call +} + +// ListLegacySnapshotsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListLegacySnapshotsApiParams +func (_e *LegacyBackupApi_Expecter) ListLegacySnapshotsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call { + return &LegacyBackupApi_ListLegacySnapshotsWithParams_Call{Call: _e.mock.On("ListLegacySnapshotsWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListLegacySnapshotsApiParams)) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListLegacySnapshotsApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsWithParams_Call) Return(_a0 admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_ListLegacySnapshotsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacySnapshotsApiParams) admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotRetention provides a mock function with given fields: ctx, groupId, clusterName, snapshotId, backupSnapshot +func (_m *LegacyBackupApi) UpdateLegacySnapshotRetention(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshot *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId, backupSnapshot) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotRetention") + } + + var r0 admin.UpdateLegacySnapshotRetentionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId, backupSnapshot) + } else { + r0 = ret.Get(0).(admin.UpdateLegacySnapshotRetentionApiRequest) + } + + return r0 +} + +// LegacyBackupApi_UpdateLegacySnapshotRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotRetention' +type LegacyBackupApi_UpdateLegacySnapshotRetention_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotRetention is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +// - backupSnapshot *admin.BackupSnapshot +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetention(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}, backupSnapshot interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call { + return &LegacyBackupApi_UpdateLegacySnapshotRetention_Call{Call: _e.mock.On("UpdateLegacySnapshotRetention", ctx, groupId, clusterName, snapshotId, backupSnapshot)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshot *admin.BackupSnapshot)) *LegacyBackupApi_UpdateLegacySnapshotRetention_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.BackupSnapshot)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) Return(_a0 admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotRetentionExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) UpdateLegacySnapshotRetentionExecute(r admin.UpdateLegacySnapshotRetentionApiRequest) (*admin.BackupSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotRetentionExecute") + } + + var r0 *admin.BackupSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateLegacySnapshotRetentionApiRequest) (*admin.BackupSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateLegacySnapshotRetentionApiRequest) *admin.BackupSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateLegacySnapshotRetentionApiRequest) *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.UpdateLegacySnapshotRetentionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotRetentionExecute' +type LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotRetentionExecute is a helper method to define mock.On call +// - r admin.UpdateLegacySnapshotRetentionApiRequest +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetentionExecute(r interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call { + return &LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call{Call: _e.mock.On("UpdateLegacySnapshotRetentionExecute", r)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call) Run(run func(r admin.UpdateLegacySnapshotRetentionApiRequest)) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateLegacySnapshotRetentionApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call) Return(_a0 *admin.BackupSnapshot, _a1 *http.Response, _a2 error) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call) RunAndReturn(run func(admin.UpdateLegacySnapshotRetentionApiRequest) (*admin.BackupSnapshot, *http.Response, error)) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotRetentionWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) UpdateLegacySnapshotRetentionWithParams(ctx context.Context, args *admin.UpdateLegacySnapshotRetentionApiParams) admin.UpdateLegacySnapshotRetentionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotRetentionWithParams") + } + + var r0 admin.UpdateLegacySnapshotRetentionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateLegacySnapshotRetentionApiParams) admin.UpdateLegacySnapshotRetentionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateLegacySnapshotRetentionApiRequest) + } + + return r0 +} + +// LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotRetentionWithParams' +type LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotRetentionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateLegacySnapshotRetentionApiParams +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetentionWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call { + return &LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call{Call: _e.mock.On("UpdateLegacySnapshotRetentionWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateLegacySnapshotRetentionApiParams)) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateLegacySnapshotRetentionApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call) Return(_a0 admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateLegacySnapshotRetentionApiParams) admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotSchedule provides a mock function with given fields: ctx, groupId, clusterName, apiAtlasSnapshotSchedule +func (_m *LegacyBackupApi) UpdateLegacySnapshotSchedule(ctx context.Context, groupId string, clusterName string, apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest { + ret := _m.Called(ctx, groupId, clusterName, apiAtlasSnapshotSchedule) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotSchedule") + } + + var r0 admin.UpdateLegacySnapshotScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, apiAtlasSnapshotSchedule) + } else { + r0 = ret.Get(0).(admin.UpdateLegacySnapshotScheduleApiRequest) + } + + return r0 +} + +// LegacyBackupApi_UpdateLegacySnapshotSchedule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotSchedule' +type LegacyBackupApi_UpdateLegacySnapshotSchedule_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotSchedule is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotSchedule(ctx interface{}, groupId interface{}, clusterName interface{}, apiAtlasSnapshotSchedule interface{}) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call { + return &LegacyBackupApi_UpdateLegacySnapshotSchedule_Call{Call: _e.mock.On("UpdateLegacySnapshotSchedule", ctx, groupId, clusterName, apiAtlasSnapshotSchedule)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) Run(run func(ctx context.Context, groupId string, clusterName string, apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule)) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ApiAtlasSnapshotSchedule)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) Return(_a0 admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotScheduleExecute provides a mock function with given fields: r +func (_m *LegacyBackupApi) UpdateLegacySnapshotScheduleExecute(r admin.UpdateLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotScheduleExecute") + } + + var r0 *admin.ApiAtlasSnapshotSchedule + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateLegacySnapshotScheduleApiRequest) *admin.ApiAtlasSnapshotSchedule); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiAtlasSnapshotSchedule) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateLegacySnapshotScheduleApiRequest) *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.UpdateLegacySnapshotScheduleApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotScheduleExecute' +type LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotScheduleExecute is a helper method to define mock.On call +// - r admin.UpdateLegacySnapshotScheduleApiRequest +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotScheduleExecute(r interface{}) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call { + return &LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call{Call: _e.mock.On("UpdateLegacySnapshotScheduleExecute", r)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call) Run(run func(r admin.UpdateLegacySnapshotScheduleApiRequest)) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateLegacySnapshotScheduleApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call) Return(_a0 *admin.ApiAtlasSnapshotSchedule, _a1 *http.Response, _a2 error) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call) RunAndReturn(run func(admin.UpdateLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateLegacySnapshotScheduleWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupApi) UpdateLegacySnapshotScheduleWithParams(ctx context.Context, args *admin.UpdateLegacySnapshotScheduleApiParams) admin.UpdateLegacySnapshotScheduleApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateLegacySnapshotScheduleWithParams") + } + + var r0 admin.UpdateLegacySnapshotScheduleApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateLegacySnapshotScheduleApiParams) admin.UpdateLegacySnapshotScheduleApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateLegacySnapshotScheduleApiRequest) + } + + return r0 +} + +// LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLegacySnapshotScheduleWithParams' +type LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call struct { + *mock.Call +} + +// UpdateLegacySnapshotScheduleWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateLegacySnapshotScheduleApiParams +func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotScheduleWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call { + return &LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call{Call: _e.mock.On("UpdateLegacySnapshotScheduleWithParams", ctx, args)} +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateLegacySnapshotScheduleApiParams)) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateLegacySnapshotScheduleApiParams)) + }) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call) Return(_a0 admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateLegacySnapshotScheduleApiParams) admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewLegacyBackupApi creates a new instance of LegacyBackupApi. 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 NewLegacyBackupApi(t interface { + mock.TestingT + Cleanup(func()) +}) *LegacyBackupApi { + mock := &LegacyBackupApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/legacy_backup_restore_jobs_api.go b/mockadmin/legacy_backup_restore_jobs_api.go new file mode 100644 index 000000000..abcb96577 --- /dev/null +++ b/mockadmin/legacy_backup_restore_jobs_api.go @@ -0,0 +1,203 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// LegacyBackupRestoreJobsApi is an autogenerated mock type for the LegacyBackupRestoreJobsApi type +type LegacyBackupRestoreJobsApi struct { + mock.Mock +} + +type LegacyBackupRestoreJobsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *LegacyBackupRestoreJobsApi) EXPECT() *LegacyBackupRestoreJobsApi_Expecter { + return &LegacyBackupRestoreJobsApi_Expecter{mock: &_m.Mock} +} + +// CreateLegacyBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, backupRestoreJob +func (_m *LegacyBackupRestoreJobsApi) CreateLegacyBackupRestoreJob(ctx context.Context, groupId string, clusterName string, backupRestoreJob *admin.BackupRestoreJob) admin.CreateLegacyBackupRestoreJobApiRequest { + ret := _m.Called(ctx, groupId, clusterName, backupRestoreJob) + + if len(ret) == 0 { + panic("no return value specified for CreateLegacyBackupRestoreJob") + } + + var r0 admin.CreateLegacyBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.BackupRestoreJob) admin.CreateLegacyBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, backupRestoreJob) + } else { + r0 = ret.Get(0).(admin.CreateLegacyBackupRestoreJobApiRequest) + } + + return r0 +} + +// LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLegacyBackupRestoreJob' +type LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call struct { + *mock.Call +} + +// CreateLegacyBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - backupRestoreJob *admin.BackupRestoreJob +func (_e *LegacyBackupRestoreJobsApi_Expecter) CreateLegacyBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, backupRestoreJob interface{}) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call { + return &LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call{Call: _e.mock.On("CreateLegacyBackupRestoreJob", ctx, groupId, clusterName, backupRestoreJob)} +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, backupRestoreJob *admin.BackupRestoreJob)) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.BackupRestoreJob)) + }) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call) Return(_a0 admin.CreateLegacyBackupRestoreJobApiRequest) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.BackupRestoreJob) admin.CreateLegacyBackupRestoreJobApiRequest) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateLegacyBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *LegacyBackupRestoreJobsApi) CreateLegacyBackupRestoreJobExecute(r admin.CreateLegacyBackupRestoreJobApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateLegacyBackupRestoreJobExecute") + } + + var r0 *admin.PaginatedRestoreJob + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateLegacyBackupRestoreJobApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateLegacyBackupRestoreJobApiRequest) *admin.PaginatedRestoreJob); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedRestoreJob) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateLegacyBackupRestoreJobApiRequest) *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.CreateLegacyBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLegacyBackupRestoreJobExecute' +type LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// CreateLegacyBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.CreateLegacyBackupRestoreJobApiRequest +func (_e *LegacyBackupRestoreJobsApi_Expecter) CreateLegacyBackupRestoreJobExecute(r interface{}) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call { + return &LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateLegacyBackupRestoreJobExecute", r)} +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call) Run(run func(r admin.CreateLegacyBackupRestoreJobApiRequest)) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateLegacyBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call) Return(_a0 *admin.PaginatedRestoreJob, _a1 *http.Response, _a2 error) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateLegacyBackupRestoreJobApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error)) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateLegacyBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *LegacyBackupRestoreJobsApi) CreateLegacyBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateLegacyBackupRestoreJobApiParams) admin.CreateLegacyBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateLegacyBackupRestoreJobWithParams") + } + + var r0 admin.CreateLegacyBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateLegacyBackupRestoreJobApiParams) admin.CreateLegacyBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateLegacyBackupRestoreJobApiRequest) + } + + return r0 +} + +// LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLegacyBackupRestoreJobWithParams' +type LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// CreateLegacyBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateLegacyBackupRestoreJobApiParams +func (_e *LegacyBackupRestoreJobsApi_Expecter) CreateLegacyBackupRestoreJobWithParams(ctx interface{}, args interface{}) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call { + return &LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateLegacyBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateLegacyBackupRestoreJobApiParams)) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateLegacyBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateLegacyBackupRestoreJobApiRequest) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateLegacyBackupRestoreJobApiParams) admin.CreateLegacyBackupRestoreJobApiRequest) *LegacyBackupRestoreJobsApi_CreateLegacyBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewLegacyBackupRestoreJobsApi creates a new instance of LegacyBackupRestoreJobsApi. 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 NewLegacyBackupRestoreJobsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *LegacyBackupRestoreJobsApi { + mock := &LegacyBackupRestoreJobsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/maintenance_windows_api.go b/mockadmin/maintenance_windows_api.go new file mode 100644 index 000000000..bd14a7f42 --- /dev/null +++ b/mockadmin/maintenance_windows_api.go @@ -0,0 +1,819 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// MaintenanceWindowsApi is an autogenerated mock type for the MaintenanceWindowsApi type +type MaintenanceWindowsApi struct { + mock.Mock +} + +type MaintenanceWindowsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *MaintenanceWindowsApi) EXPECT() *MaintenanceWindowsApi_Expecter { + return &MaintenanceWindowsApi_Expecter{mock: &_m.Mock} +} + +// DeferMaintenanceWindow provides a mock function with given fields: ctx, groupId +func (_m *MaintenanceWindowsApi) DeferMaintenanceWindow(ctx context.Context, groupId string) admin.DeferMaintenanceWindowApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for DeferMaintenanceWindow") + } + + var r0 admin.DeferMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeferMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.DeferMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_DeferMaintenanceWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeferMaintenanceWindow' +type MaintenanceWindowsApi_DeferMaintenanceWindow_Call struct { + *mock.Call +} + +// DeferMaintenanceWindow is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *MaintenanceWindowsApi_Expecter) DeferMaintenanceWindow(ctx interface{}, groupId interface{}) *MaintenanceWindowsApi_DeferMaintenanceWindow_Call { + return &MaintenanceWindowsApi_DeferMaintenanceWindow_Call{Call: _e.mock.On("DeferMaintenanceWindow", ctx, groupId)} +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindow_Call) Run(run func(ctx context.Context, groupId string)) *MaintenanceWindowsApi_DeferMaintenanceWindow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindow_Call) Return(_a0 admin.DeferMaintenanceWindowApiRequest) *MaintenanceWindowsApi_DeferMaintenanceWindow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindow_Call) RunAndReturn(run func(context.Context, string) admin.DeferMaintenanceWindowApiRequest) *MaintenanceWindowsApi_DeferMaintenanceWindow_Call { + _c.Call.Return(run) + return _c +} + +// DeferMaintenanceWindowExecute provides a mock function with given fields: r +func (_m *MaintenanceWindowsApi) DeferMaintenanceWindowExecute(r admin.DeferMaintenanceWindowApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeferMaintenanceWindowExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeferMaintenanceWindowApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeferMaintenanceWindowApiRequest) *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.DeferMaintenanceWindowApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeferMaintenanceWindowExecute' +type MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call struct { + *mock.Call +} + +// DeferMaintenanceWindowExecute is a helper method to define mock.On call +// - r admin.DeferMaintenanceWindowApiRequest +func (_e *MaintenanceWindowsApi_Expecter) DeferMaintenanceWindowExecute(r interface{}) *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call { + return &MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call{Call: _e.mock.On("DeferMaintenanceWindowExecute", r)} +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call) Run(run func(r admin.DeferMaintenanceWindowApiRequest)) *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeferMaintenanceWindowApiRequest)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call) Return(_a0 *http.Response, _a1 error) *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call) RunAndReturn(run func(admin.DeferMaintenanceWindowApiRequest) (*http.Response, error)) *MaintenanceWindowsApi_DeferMaintenanceWindowExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeferMaintenanceWindowWithParams provides a mock function with given fields: ctx, args +func (_m *MaintenanceWindowsApi) DeferMaintenanceWindowWithParams(ctx context.Context, args *admin.DeferMaintenanceWindowApiParams) admin.DeferMaintenanceWindowApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeferMaintenanceWindowWithParams") + } + + var r0 admin.DeferMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeferMaintenanceWindowApiParams) admin.DeferMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeferMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeferMaintenanceWindowWithParams' +type MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call struct { + *mock.Call +} + +// DeferMaintenanceWindowWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeferMaintenanceWindowApiParams +func (_e *MaintenanceWindowsApi_Expecter) DeferMaintenanceWindowWithParams(ctx interface{}, args interface{}) *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call { + return &MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call{Call: _e.mock.On("DeferMaintenanceWindowWithParams", ctx, args)} +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call) Run(run func(ctx context.Context, args *admin.DeferMaintenanceWindowApiParams)) *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeferMaintenanceWindowApiParams)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call) Return(_a0 admin.DeferMaintenanceWindowApiRequest) *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeferMaintenanceWindowApiParams) admin.DeferMaintenanceWindowApiRequest) *MaintenanceWindowsApi_DeferMaintenanceWindowWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetMaintenanceWindow provides a mock function with given fields: ctx, groupId +func (_m *MaintenanceWindowsApi) GetMaintenanceWindow(ctx context.Context, groupId string) admin.GetMaintenanceWindowApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetMaintenanceWindow") + } + + var r0 admin.GetMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_GetMaintenanceWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaintenanceWindow' +type MaintenanceWindowsApi_GetMaintenanceWindow_Call struct { + *mock.Call +} + +// GetMaintenanceWindow is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *MaintenanceWindowsApi_Expecter) GetMaintenanceWindow(ctx interface{}, groupId interface{}) *MaintenanceWindowsApi_GetMaintenanceWindow_Call { + return &MaintenanceWindowsApi_GetMaintenanceWindow_Call{Call: _e.mock.On("GetMaintenanceWindow", ctx, groupId)} +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindow_Call) Run(run func(ctx context.Context, groupId string)) *MaintenanceWindowsApi_GetMaintenanceWindow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindow_Call) Return(_a0 admin.GetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_GetMaintenanceWindow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindow_Call) RunAndReturn(run func(context.Context, string) admin.GetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_GetMaintenanceWindow_Call { + _c.Call.Return(run) + return _c +} + +// GetMaintenanceWindowExecute provides a mock function with given fields: r +func (_m *MaintenanceWindowsApi) GetMaintenanceWindowExecute(r admin.GetMaintenanceWindowApiRequest) (*admin.GroupMaintenanceWindow, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetMaintenanceWindowExecute") + } + + var r0 *admin.GroupMaintenanceWindow + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetMaintenanceWindowApiRequest) (*admin.GroupMaintenanceWindow, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetMaintenanceWindowApiRequest) *admin.GroupMaintenanceWindow); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.GroupMaintenanceWindow) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetMaintenanceWindowApiRequest) *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.GetMaintenanceWindowApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaintenanceWindowExecute' +type MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call struct { + *mock.Call +} + +// GetMaintenanceWindowExecute is a helper method to define mock.On call +// - r admin.GetMaintenanceWindowApiRequest +func (_e *MaintenanceWindowsApi_Expecter) GetMaintenanceWindowExecute(r interface{}) *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call { + return &MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call{Call: _e.mock.On("GetMaintenanceWindowExecute", r)} +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call) Run(run func(r admin.GetMaintenanceWindowApiRequest)) *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetMaintenanceWindowApiRequest)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call) Return(_a0 *admin.GroupMaintenanceWindow, _a1 *http.Response, _a2 error) *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call) RunAndReturn(run func(admin.GetMaintenanceWindowApiRequest) (*admin.GroupMaintenanceWindow, *http.Response, error)) *MaintenanceWindowsApi_GetMaintenanceWindowExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetMaintenanceWindowWithParams provides a mock function with given fields: ctx, args +func (_m *MaintenanceWindowsApi) GetMaintenanceWindowWithParams(ctx context.Context, args *admin.GetMaintenanceWindowApiParams) admin.GetMaintenanceWindowApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetMaintenanceWindowWithParams") + } + + var r0 admin.GetMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetMaintenanceWindowApiParams) admin.GetMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMaintenanceWindowWithParams' +type MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call struct { + *mock.Call +} + +// GetMaintenanceWindowWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetMaintenanceWindowApiParams +func (_e *MaintenanceWindowsApi_Expecter) GetMaintenanceWindowWithParams(ctx interface{}, args interface{}) *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call { + return &MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call{Call: _e.mock.On("GetMaintenanceWindowWithParams", ctx, args)} +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call) Run(run func(ctx context.Context, args *admin.GetMaintenanceWindowApiParams)) *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetMaintenanceWindowApiParams)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call) Return(_a0 admin.GetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetMaintenanceWindowApiParams) admin.GetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_GetMaintenanceWindowWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ResetMaintenanceWindow provides a mock function with given fields: ctx, groupId +func (_m *MaintenanceWindowsApi) ResetMaintenanceWindow(ctx context.Context, groupId string) admin.ResetMaintenanceWindowApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ResetMaintenanceWindow") + } + + var r0 admin.ResetMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ResetMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ResetMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_ResetMaintenanceWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetMaintenanceWindow' +type MaintenanceWindowsApi_ResetMaintenanceWindow_Call struct { + *mock.Call +} + +// ResetMaintenanceWindow is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *MaintenanceWindowsApi_Expecter) ResetMaintenanceWindow(ctx interface{}, groupId interface{}) *MaintenanceWindowsApi_ResetMaintenanceWindow_Call { + return &MaintenanceWindowsApi_ResetMaintenanceWindow_Call{Call: _e.mock.On("ResetMaintenanceWindow", ctx, groupId)} +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindow_Call) Run(run func(ctx context.Context, groupId string)) *MaintenanceWindowsApi_ResetMaintenanceWindow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindow_Call) Return(_a0 admin.ResetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_ResetMaintenanceWindow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindow_Call) RunAndReturn(run func(context.Context, string) admin.ResetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_ResetMaintenanceWindow_Call { + _c.Call.Return(run) + return _c +} + +// ResetMaintenanceWindowExecute provides a mock function with given fields: r +func (_m *MaintenanceWindowsApi) ResetMaintenanceWindowExecute(r admin.ResetMaintenanceWindowApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ResetMaintenanceWindowExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.ResetMaintenanceWindowApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ResetMaintenanceWindowApiRequest) *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.ResetMaintenanceWindowApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetMaintenanceWindowExecute' +type MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call struct { + *mock.Call +} + +// ResetMaintenanceWindowExecute is a helper method to define mock.On call +// - r admin.ResetMaintenanceWindowApiRequest +func (_e *MaintenanceWindowsApi_Expecter) ResetMaintenanceWindowExecute(r interface{}) *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call { + return &MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call{Call: _e.mock.On("ResetMaintenanceWindowExecute", r)} +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call) Run(run func(r admin.ResetMaintenanceWindowApiRequest)) *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ResetMaintenanceWindowApiRequest)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call) Return(_a0 *http.Response, _a1 error) *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call) RunAndReturn(run func(admin.ResetMaintenanceWindowApiRequest) (*http.Response, error)) *MaintenanceWindowsApi_ResetMaintenanceWindowExecute_Call { + _c.Call.Return(run) + return _c +} + +// ResetMaintenanceWindowWithParams provides a mock function with given fields: ctx, args +func (_m *MaintenanceWindowsApi) ResetMaintenanceWindowWithParams(ctx context.Context, args *admin.ResetMaintenanceWindowApiParams) admin.ResetMaintenanceWindowApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ResetMaintenanceWindowWithParams") + } + + var r0 admin.ResetMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ResetMaintenanceWindowApiParams) admin.ResetMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ResetMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetMaintenanceWindowWithParams' +type MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call struct { + *mock.Call +} + +// ResetMaintenanceWindowWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ResetMaintenanceWindowApiParams +func (_e *MaintenanceWindowsApi_Expecter) ResetMaintenanceWindowWithParams(ctx interface{}, args interface{}) *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call { + return &MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call{Call: _e.mock.On("ResetMaintenanceWindowWithParams", ctx, args)} +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call) Run(run func(ctx context.Context, args *admin.ResetMaintenanceWindowApiParams)) *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ResetMaintenanceWindowApiParams)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call) Return(_a0 admin.ResetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call) RunAndReturn(run func(context.Context, *admin.ResetMaintenanceWindowApiParams) admin.ResetMaintenanceWindowApiRequest) *MaintenanceWindowsApi_ResetMaintenanceWindowWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ToggleMaintenanceAutoDefer provides a mock function with given fields: ctx, groupId +func (_m *MaintenanceWindowsApi) ToggleMaintenanceAutoDefer(ctx context.Context, groupId string) admin.ToggleMaintenanceAutoDeferApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ToggleMaintenanceAutoDefer") + } + + var r0 admin.ToggleMaintenanceAutoDeferApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ToggleMaintenanceAutoDeferApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ToggleMaintenanceAutoDeferApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleMaintenanceAutoDefer' +type MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call struct { + *mock.Call +} + +// ToggleMaintenanceAutoDefer is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *MaintenanceWindowsApi_Expecter) ToggleMaintenanceAutoDefer(ctx interface{}, groupId interface{}) *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call { + return &MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call{Call: _e.mock.On("ToggleMaintenanceAutoDefer", ctx, groupId)} +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call) Run(run func(ctx context.Context, groupId string)) *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call) Return(_a0 admin.ToggleMaintenanceAutoDeferApiRequest) *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call) RunAndReturn(run func(context.Context, string) admin.ToggleMaintenanceAutoDeferApiRequest) *MaintenanceWindowsApi_ToggleMaintenanceAutoDefer_Call { + _c.Call.Return(run) + return _c +} + +// ToggleMaintenanceAutoDeferExecute provides a mock function with given fields: r +func (_m *MaintenanceWindowsApi) ToggleMaintenanceAutoDeferExecute(r admin.ToggleMaintenanceAutoDeferApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ToggleMaintenanceAutoDeferExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.ToggleMaintenanceAutoDeferApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ToggleMaintenanceAutoDeferApiRequest) *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.ToggleMaintenanceAutoDeferApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleMaintenanceAutoDeferExecute' +type MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call struct { + *mock.Call +} + +// ToggleMaintenanceAutoDeferExecute is a helper method to define mock.On call +// - r admin.ToggleMaintenanceAutoDeferApiRequest +func (_e *MaintenanceWindowsApi_Expecter) ToggleMaintenanceAutoDeferExecute(r interface{}) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call { + return &MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call{Call: _e.mock.On("ToggleMaintenanceAutoDeferExecute", r)} +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call) Run(run func(r admin.ToggleMaintenanceAutoDeferApiRequest)) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ToggleMaintenanceAutoDeferApiRequest)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call) Return(_a0 *http.Response, _a1 error) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call) RunAndReturn(run func(admin.ToggleMaintenanceAutoDeferApiRequest) (*http.Response, error)) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferExecute_Call { + _c.Call.Return(run) + return _c +} + +// ToggleMaintenanceAutoDeferWithParams provides a mock function with given fields: ctx, args +func (_m *MaintenanceWindowsApi) ToggleMaintenanceAutoDeferWithParams(ctx context.Context, args *admin.ToggleMaintenanceAutoDeferApiParams) admin.ToggleMaintenanceAutoDeferApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ToggleMaintenanceAutoDeferWithParams") + } + + var r0 admin.ToggleMaintenanceAutoDeferApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ToggleMaintenanceAutoDeferApiParams) admin.ToggleMaintenanceAutoDeferApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ToggleMaintenanceAutoDeferApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleMaintenanceAutoDeferWithParams' +type MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call struct { + *mock.Call +} + +// ToggleMaintenanceAutoDeferWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ToggleMaintenanceAutoDeferApiParams +func (_e *MaintenanceWindowsApi_Expecter) ToggleMaintenanceAutoDeferWithParams(ctx interface{}, args interface{}) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call { + return &MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call{Call: _e.mock.On("ToggleMaintenanceAutoDeferWithParams", ctx, args)} +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call) Run(run func(ctx context.Context, args *admin.ToggleMaintenanceAutoDeferApiParams)) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ToggleMaintenanceAutoDeferApiParams)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call) Return(_a0 admin.ToggleMaintenanceAutoDeferApiRequest) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call) RunAndReturn(run func(context.Context, *admin.ToggleMaintenanceAutoDeferApiParams) admin.ToggleMaintenanceAutoDeferApiRequest) *MaintenanceWindowsApi_ToggleMaintenanceAutoDeferWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateMaintenanceWindow provides a mock function with given fields: ctx, groupId, groupMaintenanceWindow +func (_m *MaintenanceWindowsApi) UpdateMaintenanceWindow(ctx context.Context, groupId string, groupMaintenanceWindow *admin.GroupMaintenanceWindow) admin.UpdateMaintenanceWindowApiRequest { + ret := _m.Called(ctx, groupId, groupMaintenanceWindow) + + if len(ret) == 0 { + panic("no return value specified for UpdateMaintenanceWindow") + } + + var r0 admin.UpdateMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.GroupMaintenanceWindow) admin.UpdateMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, groupId, groupMaintenanceWindow) + } else { + r0 = ret.Get(0).(admin.UpdateMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_UpdateMaintenanceWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMaintenanceWindow' +type MaintenanceWindowsApi_UpdateMaintenanceWindow_Call struct { + *mock.Call +} + +// UpdateMaintenanceWindow is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - groupMaintenanceWindow *admin.GroupMaintenanceWindow +func (_e *MaintenanceWindowsApi_Expecter) UpdateMaintenanceWindow(ctx interface{}, groupId interface{}, groupMaintenanceWindow interface{}) *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call { + return &MaintenanceWindowsApi_UpdateMaintenanceWindow_Call{Call: _e.mock.On("UpdateMaintenanceWindow", ctx, groupId, groupMaintenanceWindow)} +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call) Run(run func(ctx context.Context, groupId string, groupMaintenanceWindow *admin.GroupMaintenanceWindow)) *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.GroupMaintenanceWindow)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call) Return(_a0 admin.UpdateMaintenanceWindowApiRequest) *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call) RunAndReturn(run func(context.Context, string, *admin.GroupMaintenanceWindow) admin.UpdateMaintenanceWindowApiRequest) *MaintenanceWindowsApi_UpdateMaintenanceWindow_Call { + _c.Call.Return(run) + return _c +} + +// UpdateMaintenanceWindowExecute provides a mock function with given fields: r +func (_m *MaintenanceWindowsApi) UpdateMaintenanceWindowExecute(r admin.UpdateMaintenanceWindowApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateMaintenanceWindowExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateMaintenanceWindowApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateMaintenanceWindowApiRequest) 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.UpdateMaintenanceWindowApiRequest) *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.UpdateMaintenanceWindowApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMaintenanceWindowExecute' +type MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call struct { + *mock.Call +} + +// UpdateMaintenanceWindowExecute is a helper method to define mock.On call +// - r admin.UpdateMaintenanceWindowApiRequest +func (_e *MaintenanceWindowsApi_Expecter) UpdateMaintenanceWindowExecute(r interface{}) *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call { + return &MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call{Call: _e.mock.On("UpdateMaintenanceWindowExecute", r)} +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call) Run(run func(r admin.UpdateMaintenanceWindowApiRequest)) *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateMaintenanceWindowApiRequest)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call) RunAndReturn(run func(admin.UpdateMaintenanceWindowApiRequest) (map[string]interface{}, *http.Response, error)) *MaintenanceWindowsApi_UpdateMaintenanceWindowExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateMaintenanceWindowWithParams provides a mock function with given fields: ctx, args +func (_m *MaintenanceWindowsApi) UpdateMaintenanceWindowWithParams(ctx context.Context, args *admin.UpdateMaintenanceWindowApiParams) admin.UpdateMaintenanceWindowApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateMaintenanceWindowWithParams") + } + + var r0 admin.UpdateMaintenanceWindowApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateMaintenanceWindowApiParams) admin.UpdateMaintenanceWindowApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateMaintenanceWindowApiRequest) + } + + return r0 +} + +// MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMaintenanceWindowWithParams' +type MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call struct { + *mock.Call +} + +// UpdateMaintenanceWindowWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateMaintenanceWindowApiParams +func (_e *MaintenanceWindowsApi_Expecter) UpdateMaintenanceWindowWithParams(ctx interface{}, args interface{}) *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call { + return &MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call{Call: _e.mock.On("UpdateMaintenanceWindowWithParams", ctx, args)} +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateMaintenanceWindowApiParams)) *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateMaintenanceWindowApiParams)) + }) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call) Return(_a0 admin.UpdateMaintenanceWindowApiRequest) *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateMaintenanceWindowApiParams) admin.UpdateMaintenanceWindowApiRequest) *MaintenanceWindowsApi_UpdateMaintenanceWindowWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewMaintenanceWindowsApi creates a new instance of MaintenanceWindowsApi. 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 NewMaintenanceWindowsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *MaintenanceWindowsApi { + mock := &MaintenanceWindowsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/mongo_db_cloud_users_api.go b/mockadmin/mongo_db_cloud_users_api.go new file mode 100644 index 000000000..d6c3e896a --- /dev/null +++ b/mockadmin/mongo_db_cloud_users_api.go @@ -0,0 +1,523 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// MongoDBCloudUsersApi is an autogenerated mock type for the MongoDBCloudUsersApi type +type MongoDBCloudUsersApi struct { + mock.Mock +} + +type MongoDBCloudUsersApi_Expecter struct { + mock *mock.Mock +} + +func (_m *MongoDBCloudUsersApi) EXPECT() *MongoDBCloudUsersApi_Expecter { + return &MongoDBCloudUsersApi_Expecter{mock: &_m.Mock} +} + +// CreateUser provides a mock function with given fields: ctx, cloudAppUser +func (_m *MongoDBCloudUsersApi) CreateUser(ctx context.Context, cloudAppUser *admin.CloudAppUser) admin.CreateUserApiRequest { + ret := _m.Called(ctx, cloudAppUser) + + if len(ret) == 0 { + panic("no return value specified for CreateUser") + } + + var r0 admin.CreateUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CloudAppUser) admin.CreateUserApiRequest); ok { + r0 = rf(ctx, cloudAppUser) + } else { + r0 = ret.Get(0).(admin.CreateUserApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser' +type MongoDBCloudUsersApi_CreateUser_Call struct { + *mock.Call +} + +// CreateUser is a helper method to define mock.On call +// - ctx context.Context +// - cloudAppUser *admin.CloudAppUser +func (_e *MongoDBCloudUsersApi_Expecter) CreateUser(ctx interface{}, cloudAppUser interface{}) *MongoDBCloudUsersApi_CreateUser_Call { + return &MongoDBCloudUsersApi_CreateUser_Call{Call: _e.mock.On("CreateUser", ctx, cloudAppUser)} +} + +func (_c *MongoDBCloudUsersApi_CreateUser_Call) Run(run func(ctx context.Context, cloudAppUser *admin.CloudAppUser)) *MongoDBCloudUsersApi_CreateUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CloudAppUser)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUser_Call) Return(_a0 admin.CreateUserApiRequest) *MongoDBCloudUsersApi_CreateUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUser_Call) RunAndReturn(run func(context.Context, *admin.CloudAppUser) admin.CreateUserApiRequest) *MongoDBCloudUsersApi_CreateUser_Call { + _c.Call.Return(run) + return _c +} + +// CreateUserExecute provides a mock function with given fields: r +func (_m *MongoDBCloudUsersApi) CreateUserExecute(r admin.CreateUserApiRequest) (*admin.CloudAppUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateUserExecute") + } + + var r0 *admin.CloudAppUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateUserApiRequest) (*admin.CloudAppUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateUserApiRequest) *admin.CloudAppUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudAppUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateUserApiRequest) *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.CreateUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MongoDBCloudUsersApi_CreateUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserExecute' +type MongoDBCloudUsersApi_CreateUserExecute_Call struct { + *mock.Call +} + +// CreateUserExecute is a helper method to define mock.On call +// - r admin.CreateUserApiRequest +func (_e *MongoDBCloudUsersApi_Expecter) CreateUserExecute(r interface{}) *MongoDBCloudUsersApi_CreateUserExecute_Call { + return &MongoDBCloudUsersApi_CreateUserExecute_Call{Call: _e.mock.On("CreateUserExecute", r)} +} + +func (_c *MongoDBCloudUsersApi_CreateUserExecute_Call) Run(run func(r admin.CreateUserApiRequest)) *MongoDBCloudUsersApi_CreateUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateUserApiRequest)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUserExecute_Call) Return(_a0 *admin.CloudAppUser, _a1 *http.Response, _a2 error) *MongoDBCloudUsersApi_CreateUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUserExecute_Call) RunAndReturn(run func(admin.CreateUserApiRequest) (*admin.CloudAppUser, *http.Response, error)) *MongoDBCloudUsersApi_CreateUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateUserWithParams provides a mock function with given fields: ctx, args +func (_m *MongoDBCloudUsersApi) CreateUserWithParams(ctx context.Context, args *admin.CreateUserApiParams) admin.CreateUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateUserWithParams") + } + + var r0 admin.CreateUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateUserApiParams) admin.CreateUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateUserApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_CreateUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserWithParams' +type MongoDBCloudUsersApi_CreateUserWithParams_Call struct { + *mock.Call +} + +// CreateUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateUserApiParams +func (_e *MongoDBCloudUsersApi_Expecter) CreateUserWithParams(ctx interface{}, args interface{}) *MongoDBCloudUsersApi_CreateUserWithParams_Call { + return &MongoDBCloudUsersApi_CreateUserWithParams_Call{Call: _e.mock.On("CreateUserWithParams", ctx, args)} +} + +func (_c *MongoDBCloudUsersApi_CreateUserWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateUserApiParams)) *MongoDBCloudUsersApi_CreateUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateUserApiParams)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUserWithParams_Call) Return(_a0 admin.CreateUserApiRequest) *MongoDBCloudUsersApi_CreateUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_CreateUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateUserApiParams) admin.CreateUserApiRequest) *MongoDBCloudUsersApi_CreateUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetUser provides a mock function with given fields: ctx, userId +func (_m *MongoDBCloudUsersApi) GetUser(ctx context.Context, userId string) admin.GetUserApiRequest { + ret := _m.Called(ctx, userId) + + if len(ret) == 0 { + panic("no return value specified for GetUser") + } + + var r0 admin.GetUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetUserApiRequest); ok { + r0 = rf(ctx, userId) + } else { + r0 = ret.Get(0).(admin.GetUserApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_GetUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUser' +type MongoDBCloudUsersApi_GetUser_Call struct { + *mock.Call +} + +// GetUser is a helper method to define mock.On call +// - ctx context.Context +// - userId string +func (_e *MongoDBCloudUsersApi_Expecter) GetUser(ctx interface{}, userId interface{}) *MongoDBCloudUsersApi_GetUser_Call { + return &MongoDBCloudUsersApi_GetUser_Call{Call: _e.mock.On("GetUser", ctx, userId)} +} + +func (_c *MongoDBCloudUsersApi_GetUser_Call) Run(run func(ctx context.Context, userId string)) *MongoDBCloudUsersApi_GetUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUser_Call) Return(_a0 admin.GetUserApiRequest) *MongoDBCloudUsersApi_GetUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUser_Call) RunAndReturn(run func(context.Context, string) admin.GetUserApiRequest) *MongoDBCloudUsersApi_GetUser_Call { + _c.Call.Return(run) + return _c +} + +// GetUserByUsername provides a mock function with given fields: ctx, userName +func (_m *MongoDBCloudUsersApi) GetUserByUsername(ctx context.Context, userName string) admin.GetUserByUsernameApiRequest { + ret := _m.Called(ctx, userName) + + if len(ret) == 0 { + panic("no return value specified for GetUserByUsername") + } + + var r0 admin.GetUserByUsernameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetUserByUsernameApiRequest); ok { + r0 = rf(ctx, userName) + } else { + r0 = ret.Get(0).(admin.GetUserByUsernameApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_GetUserByUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByUsername' +type MongoDBCloudUsersApi_GetUserByUsername_Call struct { + *mock.Call +} + +// GetUserByUsername is a helper method to define mock.On call +// - ctx context.Context +// - userName string +func (_e *MongoDBCloudUsersApi_Expecter) GetUserByUsername(ctx interface{}, userName interface{}) *MongoDBCloudUsersApi_GetUserByUsername_Call { + return &MongoDBCloudUsersApi_GetUserByUsername_Call{Call: _e.mock.On("GetUserByUsername", ctx, userName)} +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsername_Call) Run(run func(ctx context.Context, userName string)) *MongoDBCloudUsersApi_GetUserByUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsername_Call) Return(_a0 admin.GetUserByUsernameApiRequest) *MongoDBCloudUsersApi_GetUserByUsername_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsername_Call) RunAndReturn(run func(context.Context, string) admin.GetUserByUsernameApiRequest) *MongoDBCloudUsersApi_GetUserByUsername_Call { + _c.Call.Return(run) + return _c +} + +// GetUserByUsernameExecute provides a mock function with given fields: r +func (_m *MongoDBCloudUsersApi) GetUserByUsernameExecute(r admin.GetUserByUsernameApiRequest) (*admin.CloudAppUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetUserByUsernameExecute") + } + + var r0 *admin.CloudAppUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetUserByUsernameApiRequest) (*admin.CloudAppUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetUserByUsernameApiRequest) *admin.CloudAppUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudAppUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetUserByUsernameApiRequest) *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.GetUserByUsernameApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MongoDBCloudUsersApi_GetUserByUsernameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByUsernameExecute' +type MongoDBCloudUsersApi_GetUserByUsernameExecute_Call struct { + *mock.Call +} + +// GetUserByUsernameExecute is a helper method to define mock.On call +// - r admin.GetUserByUsernameApiRequest +func (_e *MongoDBCloudUsersApi_Expecter) GetUserByUsernameExecute(r interface{}) *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call { + return &MongoDBCloudUsersApi_GetUserByUsernameExecute_Call{Call: _e.mock.On("GetUserByUsernameExecute", r)} +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call) Run(run func(r admin.GetUserByUsernameApiRequest)) *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetUserByUsernameApiRequest)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call) Return(_a0 *admin.CloudAppUser, _a1 *http.Response, _a2 error) *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call) RunAndReturn(run func(admin.GetUserByUsernameApiRequest) (*admin.CloudAppUser, *http.Response, error)) *MongoDBCloudUsersApi_GetUserByUsernameExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetUserByUsernameWithParams provides a mock function with given fields: ctx, args +func (_m *MongoDBCloudUsersApi) GetUserByUsernameWithParams(ctx context.Context, args *admin.GetUserByUsernameApiParams) admin.GetUserByUsernameApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetUserByUsernameWithParams") + } + + var r0 admin.GetUserByUsernameApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetUserByUsernameApiParams) admin.GetUserByUsernameApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetUserByUsernameApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByUsernameWithParams' +type MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call struct { + *mock.Call +} + +// GetUserByUsernameWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetUserByUsernameApiParams +func (_e *MongoDBCloudUsersApi_Expecter) GetUserByUsernameWithParams(ctx interface{}, args interface{}) *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call { + return &MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call{Call: _e.mock.On("GetUserByUsernameWithParams", ctx, args)} +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call) Run(run func(ctx context.Context, args *admin.GetUserByUsernameApiParams)) *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetUserByUsernameApiParams)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call) Return(_a0 admin.GetUserByUsernameApiRequest) *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetUserByUsernameApiParams) admin.GetUserByUsernameApiRequest) *MongoDBCloudUsersApi_GetUserByUsernameWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetUserExecute provides a mock function with given fields: r +func (_m *MongoDBCloudUsersApi) GetUserExecute(r admin.GetUserApiRequest) (*admin.CloudAppUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetUserExecute") + } + + var r0 *admin.CloudAppUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetUserApiRequest) (*admin.CloudAppUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetUserApiRequest) *admin.CloudAppUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudAppUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetUserApiRequest) *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.GetUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MongoDBCloudUsersApi_GetUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserExecute' +type MongoDBCloudUsersApi_GetUserExecute_Call struct { + *mock.Call +} + +// GetUserExecute is a helper method to define mock.On call +// - r admin.GetUserApiRequest +func (_e *MongoDBCloudUsersApi_Expecter) GetUserExecute(r interface{}) *MongoDBCloudUsersApi_GetUserExecute_Call { + return &MongoDBCloudUsersApi_GetUserExecute_Call{Call: _e.mock.On("GetUserExecute", r)} +} + +func (_c *MongoDBCloudUsersApi_GetUserExecute_Call) Run(run func(r admin.GetUserApiRequest)) *MongoDBCloudUsersApi_GetUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetUserApiRequest)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserExecute_Call) Return(_a0 *admin.CloudAppUser, _a1 *http.Response, _a2 error) *MongoDBCloudUsersApi_GetUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserExecute_Call) RunAndReturn(run func(admin.GetUserApiRequest) (*admin.CloudAppUser, *http.Response, error)) *MongoDBCloudUsersApi_GetUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetUserWithParams provides a mock function with given fields: ctx, args +func (_m *MongoDBCloudUsersApi) GetUserWithParams(ctx context.Context, args *admin.GetUserApiParams) admin.GetUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetUserWithParams") + } + + var r0 admin.GetUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetUserApiParams) admin.GetUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetUserApiRequest) + } + + return r0 +} + +// MongoDBCloudUsersApi_GetUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserWithParams' +type MongoDBCloudUsersApi_GetUserWithParams_Call struct { + *mock.Call +} + +// GetUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetUserApiParams +func (_e *MongoDBCloudUsersApi_Expecter) GetUserWithParams(ctx interface{}, args interface{}) *MongoDBCloudUsersApi_GetUserWithParams_Call { + return &MongoDBCloudUsersApi_GetUserWithParams_Call{Call: _e.mock.On("GetUserWithParams", ctx, args)} +} + +func (_c *MongoDBCloudUsersApi_GetUserWithParams_Call) Run(run func(ctx context.Context, args *admin.GetUserApiParams)) *MongoDBCloudUsersApi_GetUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetUserApiParams)) + }) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserWithParams_Call) Return(_a0 admin.GetUserApiRequest) *MongoDBCloudUsersApi_GetUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MongoDBCloudUsersApi_GetUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetUserApiParams) admin.GetUserApiRequest) *MongoDBCloudUsersApi_GetUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewMongoDBCloudUsersApi creates a new instance of MongoDBCloudUsersApi. 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 NewMongoDBCloudUsersApi(t interface { + mock.TestingT + Cleanup(func()) +}) *MongoDBCloudUsersApi { + mock := &MongoDBCloudUsersApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/monitoring_and_logs_api.go b/mockadmin/monitoring_and_logs_api.go new file mode 100644 index 000000000..cc8130002 --- /dev/null +++ b/mockadmin/monitoring_and_logs_api.go @@ -0,0 +1,2319 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + io "io" + + mock "github.com/stretchr/testify/mock" +) + +// MonitoringAndLogsApi is an autogenerated mock type for the MonitoringAndLogsApi type +type MonitoringAndLogsApi struct { + mock.Mock +} + +type MonitoringAndLogsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *MonitoringAndLogsApi) EXPECT() *MonitoringAndLogsApi_Expecter { + return &MonitoringAndLogsApi_Expecter{mock: &_m.Mock} +} + +// GetAtlasProcess provides a mock function with given fields: ctx, groupId, processId +func (_m *MonitoringAndLogsApi) GetAtlasProcess(ctx context.Context, groupId string, processId string) admin.GetAtlasProcessApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for GetAtlasProcess") + } + + var r0 admin.GetAtlasProcessApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetAtlasProcessApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.GetAtlasProcessApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetAtlasProcess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasProcess' +type MonitoringAndLogsApi_GetAtlasProcess_Call struct { + *mock.Call +} + +// GetAtlasProcess is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) GetAtlasProcess(ctx interface{}, groupId interface{}, processId interface{}) *MonitoringAndLogsApi_GetAtlasProcess_Call { + return &MonitoringAndLogsApi_GetAtlasProcess_Call{Call: _e.mock.On("GetAtlasProcess", ctx, groupId, processId)} +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcess_Call) Run(run func(ctx context.Context, groupId string, processId string)) *MonitoringAndLogsApi_GetAtlasProcess_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcess_Call) Return(_a0 admin.GetAtlasProcessApiRequest) *MonitoringAndLogsApi_GetAtlasProcess_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcess_Call) RunAndReturn(run func(context.Context, string, string) admin.GetAtlasProcessApiRequest) *MonitoringAndLogsApi_GetAtlasProcess_Call { + _c.Call.Return(run) + return _c +} + +// GetAtlasProcessExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetAtlasProcessExecute(r admin.GetAtlasProcessApiRequest) (*admin.ApiHostViewAtlas, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetAtlasProcessExecute") + } + + var r0 *admin.ApiHostViewAtlas + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetAtlasProcessApiRequest) (*admin.ApiHostViewAtlas, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetAtlasProcessApiRequest) *admin.ApiHostViewAtlas); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiHostViewAtlas) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetAtlasProcessApiRequest) *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.GetAtlasProcessApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetAtlasProcessExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasProcessExecute' +type MonitoringAndLogsApi_GetAtlasProcessExecute_Call struct { + *mock.Call +} + +// GetAtlasProcessExecute is a helper method to define mock.On call +// - r admin.GetAtlasProcessApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetAtlasProcessExecute(r interface{}) *MonitoringAndLogsApi_GetAtlasProcessExecute_Call { + return &MonitoringAndLogsApi_GetAtlasProcessExecute_Call{Call: _e.mock.On("GetAtlasProcessExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessExecute_Call) Run(run func(r admin.GetAtlasProcessApiRequest)) *MonitoringAndLogsApi_GetAtlasProcessExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetAtlasProcessApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessExecute_Call) Return(_a0 *admin.ApiHostViewAtlas, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetAtlasProcessExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessExecute_Call) RunAndReturn(run func(admin.GetAtlasProcessApiRequest) (*admin.ApiHostViewAtlas, *http.Response, error)) *MonitoringAndLogsApi_GetAtlasProcessExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetAtlasProcessWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetAtlasProcessWithParams(ctx context.Context, args *admin.GetAtlasProcessApiParams) admin.GetAtlasProcessApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetAtlasProcessWithParams") + } + + var r0 admin.GetAtlasProcessApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetAtlasProcessApiParams) admin.GetAtlasProcessApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetAtlasProcessApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetAtlasProcessWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAtlasProcessWithParams' +type MonitoringAndLogsApi_GetAtlasProcessWithParams_Call struct { + *mock.Call +} + +// GetAtlasProcessWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetAtlasProcessApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetAtlasProcessWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call { + return &MonitoringAndLogsApi_GetAtlasProcessWithParams_Call{Call: _e.mock.On("GetAtlasProcessWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call) Run(run func(ctx context.Context, args *admin.GetAtlasProcessApiParams)) *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetAtlasProcessApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call) Return(_a0 admin.GetAtlasProcessApiRequest) *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetAtlasProcessApiParams) admin.GetAtlasProcessApiRequest) *MonitoringAndLogsApi_GetAtlasProcessWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabase provides a mock function with given fields: ctx, groupId, databaseName, processId +func (_m *MonitoringAndLogsApi) GetDatabase(ctx context.Context, groupId string, databaseName string, processId string) admin.GetDatabaseApiRequest { + ret := _m.Called(ctx, groupId, databaseName, processId) + + if len(ret) == 0 { + panic("no return value specified for GetDatabase") + } + + var r0 admin.GetDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetDatabaseApiRequest); ok { + r0 = rf(ctx, groupId, databaseName, processId) + } else { + r0 = ret.Get(0).(admin.GetDatabaseApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabase' +type MonitoringAndLogsApi_GetDatabase_Call struct { + *mock.Call +} + +// GetDatabase is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - databaseName string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) GetDatabase(ctx interface{}, groupId interface{}, databaseName interface{}, processId interface{}) *MonitoringAndLogsApi_GetDatabase_Call { + return &MonitoringAndLogsApi_GetDatabase_Call{Call: _e.mock.On("GetDatabase", ctx, groupId, databaseName, processId)} +} + +func (_c *MonitoringAndLogsApi_GetDatabase_Call) Run(run func(ctx context.Context, groupId string, databaseName string, processId string)) *MonitoringAndLogsApi_GetDatabase_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 *MonitoringAndLogsApi_GetDatabase_Call) Return(_a0 admin.GetDatabaseApiRequest) *MonitoringAndLogsApi_GetDatabase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabase_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetDatabaseApiRequest) *MonitoringAndLogsApi_GetDatabase_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetDatabaseExecute(r admin.GetDatabaseApiRequest) (*admin.MesurementsDatabase, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseExecute") + } + + var r0 *admin.MesurementsDatabase + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDatabaseApiRequest) (*admin.MesurementsDatabase, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDatabaseApiRequest) *admin.MesurementsDatabase); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MesurementsDatabase) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDatabaseApiRequest) *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.GetDatabaseApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetDatabaseExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseExecute' +type MonitoringAndLogsApi_GetDatabaseExecute_Call struct { + *mock.Call +} + +// GetDatabaseExecute is a helper method to define mock.On call +// - r admin.GetDatabaseApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetDatabaseExecute(r interface{}) *MonitoringAndLogsApi_GetDatabaseExecute_Call { + return &MonitoringAndLogsApi_GetDatabaseExecute_Call{Call: _e.mock.On("GetDatabaseExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetDatabaseExecute_Call) Run(run func(r admin.GetDatabaseApiRequest)) *MonitoringAndLogsApi_GetDatabaseExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDatabaseApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseExecute_Call) Return(_a0 *admin.MesurementsDatabase, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetDatabaseExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseExecute_Call) RunAndReturn(run func(admin.GetDatabaseApiRequest) (*admin.MesurementsDatabase, *http.Response, error)) *MonitoringAndLogsApi_GetDatabaseExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseMeasurements provides a mock function with given fields: ctx, groupId, databaseName, processId +func (_m *MonitoringAndLogsApi) GetDatabaseMeasurements(ctx context.Context, groupId string, databaseName string, processId string) admin.GetDatabaseMeasurementsApiRequest { + ret := _m.Called(ctx, groupId, databaseName, processId) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseMeasurements") + } + + var r0 admin.GetDatabaseMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetDatabaseMeasurementsApiRequest); ok { + r0 = rf(ctx, groupId, databaseName, processId) + } else { + r0 = ret.Get(0).(admin.GetDatabaseMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDatabaseMeasurements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseMeasurements' +type MonitoringAndLogsApi_GetDatabaseMeasurements_Call struct { + *mock.Call +} + +// GetDatabaseMeasurements is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - databaseName string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) GetDatabaseMeasurements(ctx interface{}, groupId interface{}, databaseName interface{}, processId interface{}) *MonitoringAndLogsApi_GetDatabaseMeasurements_Call { + return &MonitoringAndLogsApi_GetDatabaseMeasurements_Call{Call: _e.mock.On("GetDatabaseMeasurements", ctx, groupId, databaseName, processId)} +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurements_Call) Run(run func(ctx context.Context, groupId string, databaseName string, processId string)) *MonitoringAndLogsApi_GetDatabaseMeasurements_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 *MonitoringAndLogsApi_GetDatabaseMeasurements_Call) Return(_a0 admin.GetDatabaseMeasurementsApiRequest) *MonitoringAndLogsApi_GetDatabaseMeasurements_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurements_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetDatabaseMeasurementsApiRequest) *MonitoringAndLogsApi_GetDatabaseMeasurements_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseMeasurementsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetDatabaseMeasurementsExecute(r admin.GetDatabaseMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseMeasurementsExecute") + } + + var r0 *admin.ApiMeasurementsGeneralViewAtlas + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDatabaseMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDatabaseMeasurementsApiRequest) *admin.ApiMeasurementsGeneralViewAtlas); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiMeasurementsGeneralViewAtlas) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDatabaseMeasurementsApiRequest) *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.GetDatabaseMeasurementsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseMeasurementsExecute' +type MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call struct { + *mock.Call +} + +// GetDatabaseMeasurementsExecute is a helper method to define mock.On call +// - r admin.GetDatabaseMeasurementsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetDatabaseMeasurementsExecute(r interface{}) *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call { + return &MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call{Call: _e.mock.On("GetDatabaseMeasurementsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call) Run(run func(r admin.GetDatabaseMeasurementsApiRequest)) *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDatabaseMeasurementsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call) Return(_a0 *admin.ApiMeasurementsGeneralViewAtlas, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call) RunAndReturn(run func(admin.GetDatabaseMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)) *MonitoringAndLogsApi_GetDatabaseMeasurementsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseMeasurementsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetDatabaseMeasurementsWithParams(ctx context.Context, args *admin.GetDatabaseMeasurementsApiParams) admin.GetDatabaseMeasurementsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseMeasurementsWithParams") + } + + var r0 admin.GetDatabaseMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDatabaseMeasurementsApiParams) admin.GetDatabaseMeasurementsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDatabaseMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseMeasurementsWithParams' +type MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call struct { + *mock.Call +} + +// GetDatabaseMeasurementsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDatabaseMeasurementsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetDatabaseMeasurementsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call { + return &MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call{Call: _e.mock.On("GetDatabaseMeasurementsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDatabaseMeasurementsApiParams)) *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDatabaseMeasurementsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call) Return(_a0 admin.GetDatabaseMeasurementsApiRequest) *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDatabaseMeasurementsApiParams) admin.GetDatabaseMeasurementsApiRequest) *MonitoringAndLogsApi_GetDatabaseMeasurementsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDatabaseWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetDatabaseWithParams(ctx context.Context, args *admin.GetDatabaseApiParams) admin.GetDatabaseApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDatabaseWithParams") + } + + var r0 admin.GetDatabaseApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDatabaseApiParams) admin.GetDatabaseApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDatabaseApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDatabaseWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseWithParams' +type MonitoringAndLogsApi_GetDatabaseWithParams_Call struct { + *mock.Call +} + +// GetDatabaseWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDatabaseApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetDatabaseWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetDatabaseWithParams_Call { + return &MonitoringAndLogsApi_GetDatabaseWithParams_Call{Call: _e.mock.On("GetDatabaseWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDatabaseApiParams)) *MonitoringAndLogsApi_GetDatabaseWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDatabaseApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseWithParams_Call) Return(_a0 admin.GetDatabaseApiRequest) *MonitoringAndLogsApi_GetDatabaseWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDatabaseApiParams) admin.GetDatabaseApiRequest) *MonitoringAndLogsApi_GetDatabaseWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetDiskMeasurements provides a mock function with given fields: ctx, groupId, partitionName, processId +func (_m *MonitoringAndLogsApi) GetDiskMeasurements(ctx context.Context, groupId string, partitionName string, processId string) admin.GetDiskMeasurementsApiRequest { + ret := _m.Called(ctx, groupId, partitionName, processId) + + if len(ret) == 0 { + panic("no return value specified for GetDiskMeasurements") + } + + var r0 admin.GetDiskMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetDiskMeasurementsApiRequest); ok { + r0 = rf(ctx, groupId, partitionName, processId) + } else { + r0 = ret.Get(0).(admin.GetDiskMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDiskMeasurements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDiskMeasurements' +type MonitoringAndLogsApi_GetDiskMeasurements_Call struct { + *mock.Call +} + +// GetDiskMeasurements is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - partitionName string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) GetDiskMeasurements(ctx interface{}, groupId interface{}, partitionName interface{}, processId interface{}) *MonitoringAndLogsApi_GetDiskMeasurements_Call { + return &MonitoringAndLogsApi_GetDiskMeasurements_Call{Call: _e.mock.On("GetDiskMeasurements", ctx, groupId, partitionName, processId)} +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurements_Call) Run(run func(ctx context.Context, groupId string, partitionName string, processId string)) *MonitoringAndLogsApi_GetDiskMeasurements_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 *MonitoringAndLogsApi_GetDiskMeasurements_Call) Return(_a0 admin.GetDiskMeasurementsApiRequest) *MonitoringAndLogsApi_GetDiskMeasurements_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurements_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetDiskMeasurementsApiRequest) *MonitoringAndLogsApi_GetDiskMeasurements_Call { + _c.Call.Return(run) + return _c +} + +// GetDiskMeasurementsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetDiskMeasurementsExecute(r admin.GetDiskMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetDiskMeasurementsExecute") + } + + var r0 *admin.ApiMeasurementsGeneralViewAtlas + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetDiskMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetDiskMeasurementsApiRequest) *admin.ApiMeasurementsGeneralViewAtlas); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiMeasurementsGeneralViewAtlas) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetDiskMeasurementsApiRequest) *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.GetDiskMeasurementsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDiskMeasurementsExecute' +type MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call struct { + *mock.Call +} + +// GetDiskMeasurementsExecute is a helper method to define mock.On call +// - r admin.GetDiskMeasurementsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetDiskMeasurementsExecute(r interface{}) *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call { + return &MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call{Call: _e.mock.On("GetDiskMeasurementsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call) Run(run func(r admin.GetDiskMeasurementsApiRequest)) *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetDiskMeasurementsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call) Return(_a0 *admin.ApiMeasurementsGeneralViewAtlas, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call) RunAndReturn(run func(admin.GetDiskMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)) *MonitoringAndLogsApi_GetDiskMeasurementsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetDiskMeasurementsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetDiskMeasurementsWithParams(ctx context.Context, args *admin.GetDiskMeasurementsApiParams) admin.GetDiskMeasurementsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetDiskMeasurementsWithParams") + } + + var r0 admin.GetDiskMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDiskMeasurementsApiParams) admin.GetDiskMeasurementsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetDiskMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDiskMeasurementsWithParams' +type MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call struct { + *mock.Call +} + +// GetDiskMeasurementsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetDiskMeasurementsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetDiskMeasurementsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call { + return &MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call{Call: _e.mock.On("GetDiskMeasurementsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDiskMeasurementsApiParams)) *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetDiskMeasurementsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call) Return(_a0 admin.GetDiskMeasurementsApiRequest) *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDiskMeasurementsApiParams) admin.GetDiskMeasurementsApiRequest) *MonitoringAndLogsApi_GetDiskMeasurementsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetHostLogs provides a mock function with given fields: ctx, groupId, hostName, logName +func (_m *MonitoringAndLogsApi) GetHostLogs(ctx context.Context, groupId string, hostName string, logName string) admin.GetHostLogsApiRequest { + ret := _m.Called(ctx, groupId, hostName, logName) + + if len(ret) == 0 { + panic("no return value specified for GetHostLogs") + } + + var r0 admin.GetHostLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetHostLogsApiRequest); ok { + r0 = rf(ctx, groupId, hostName, logName) + } else { + r0 = ret.Get(0).(admin.GetHostLogsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetHostLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostLogs' +type MonitoringAndLogsApi_GetHostLogs_Call struct { + *mock.Call +} + +// GetHostLogs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - hostName string +// - logName string +func (_e *MonitoringAndLogsApi_Expecter) GetHostLogs(ctx interface{}, groupId interface{}, hostName interface{}, logName interface{}) *MonitoringAndLogsApi_GetHostLogs_Call { + return &MonitoringAndLogsApi_GetHostLogs_Call{Call: _e.mock.On("GetHostLogs", ctx, groupId, hostName, logName)} +} + +func (_c *MonitoringAndLogsApi_GetHostLogs_Call) Run(run func(ctx context.Context, groupId string, hostName string, logName string)) *MonitoringAndLogsApi_GetHostLogs_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 *MonitoringAndLogsApi_GetHostLogs_Call) Return(_a0 admin.GetHostLogsApiRequest) *MonitoringAndLogsApi_GetHostLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostLogs_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetHostLogsApiRequest) *MonitoringAndLogsApi_GetHostLogs_Call { + _c.Call.Return(run) + return _c +} + +// GetHostLogsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetHostLogsExecute(r admin.GetHostLogsApiRequest) (io.ReadCloser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetHostLogsExecute") + } + + var r0 io.ReadCloser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetHostLogsApiRequest) (io.ReadCloser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetHostLogsApiRequest) io.ReadCloser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetHostLogsApiRequest) *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.GetHostLogsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetHostLogsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostLogsExecute' +type MonitoringAndLogsApi_GetHostLogsExecute_Call struct { + *mock.Call +} + +// GetHostLogsExecute is a helper method to define mock.On call +// - r admin.GetHostLogsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetHostLogsExecute(r interface{}) *MonitoringAndLogsApi_GetHostLogsExecute_Call { + return &MonitoringAndLogsApi_GetHostLogsExecute_Call{Call: _e.mock.On("GetHostLogsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetHostLogsExecute_Call) Run(run func(r admin.GetHostLogsApiRequest)) *MonitoringAndLogsApi_GetHostLogsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetHostLogsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetHostLogsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostLogsExecute_Call) RunAndReturn(run func(admin.GetHostLogsApiRequest) (io.ReadCloser, *http.Response, error)) *MonitoringAndLogsApi_GetHostLogsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetHostLogsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetHostLogsWithParams(ctx context.Context, args *admin.GetHostLogsApiParams) admin.GetHostLogsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetHostLogsWithParams") + } + + var r0 admin.GetHostLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetHostLogsApiParams) admin.GetHostLogsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetHostLogsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetHostLogsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostLogsWithParams' +type MonitoringAndLogsApi_GetHostLogsWithParams_Call struct { + *mock.Call +} + +// GetHostLogsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetHostLogsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetHostLogsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetHostLogsWithParams_Call { + return &MonitoringAndLogsApi_GetHostLogsWithParams_Call{Call: _e.mock.On("GetHostLogsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetHostLogsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetHostLogsApiParams)) *MonitoringAndLogsApi_GetHostLogsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetHostLogsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostLogsWithParams_Call) Return(_a0 admin.GetHostLogsApiRequest) *MonitoringAndLogsApi_GetHostLogsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetHostLogsApiParams) admin.GetHostLogsApiRequest) *MonitoringAndLogsApi_GetHostLogsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetHostMeasurements provides a mock function with given fields: ctx, groupId, processId +func (_m *MonitoringAndLogsApi) GetHostMeasurements(ctx context.Context, groupId string, processId string) admin.GetHostMeasurementsApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for GetHostMeasurements") + } + + var r0 admin.GetHostMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetHostMeasurementsApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.GetHostMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetHostMeasurements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostMeasurements' +type MonitoringAndLogsApi_GetHostMeasurements_Call struct { + *mock.Call +} + +// GetHostMeasurements is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) GetHostMeasurements(ctx interface{}, groupId interface{}, processId interface{}) *MonitoringAndLogsApi_GetHostMeasurements_Call { + return &MonitoringAndLogsApi_GetHostMeasurements_Call{Call: _e.mock.On("GetHostMeasurements", ctx, groupId, processId)} +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurements_Call) Run(run func(ctx context.Context, groupId string, processId string)) *MonitoringAndLogsApi_GetHostMeasurements_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurements_Call) Return(_a0 admin.GetHostMeasurementsApiRequest) *MonitoringAndLogsApi_GetHostMeasurements_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurements_Call) RunAndReturn(run func(context.Context, string, string) admin.GetHostMeasurementsApiRequest) *MonitoringAndLogsApi_GetHostMeasurements_Call { + _c.Call.Return(run) + return _c +} + +// GetHostMeasurementsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetHostMeasurementsExecute(r admin.GetHostMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetHostMeasurementsExecute") + } + + var r0 *admin.ApiMeasurementsGeneralViewAtlas + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetHostMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetHostMeasurementsApiRequest) *admin.ApiMeasurementsGeneralViewAtlas); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiMeasurementsGeneralViewAtlas) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetHostMeasurementsApiRequest) *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.GetHostMeasurementsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetHostMeasurementsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostMeasurementsExecute' +type MonitoringAndLogsApi_GetHostMeasurementsExecute_Call struct { + *mock.Call +} + +// GetHostMeasurementsExecute is a helper method to define mock.On call +// - r admin.GetHostMeasurementsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetHostMeasurementsExecute(r interface{}) *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call { + return &MonitoringAndLogsApi_GetHostMeasurementsExecute_Call{Call: _e.mock.On("GetHostMeasurementsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call) Run(run func(r admin.GetHostMeasurementsApiRequest)) *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetHostMeasurementsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call) Return(_a0 *admin.ApiMeasurementsGeneralViewAtlas, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call) RunAndReturn(run func(admin.GetHostMeasurementsApiRequest) (*admin.ApiMeasurementsGeneralViewAtlas, *http.Response, error)) *MonitoringAndLogsApi_GetHostMeasurementsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetHostMeasurementsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetHostMeasurementsWithParams(ctx context.Context, args *admin.GetHostMeasurementsApiParams) admin.GetHostMeasurementsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetHostMeasurementsWithParams") + } + + var r0 admin.GetHostMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetHostMeasurementsApiParams) admin.GetHostMeasurementsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetHostMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostMeasurementsWithParams' +type MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call struct { + *mock.Call +} + +// GetHostMeasurementsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetHostMeasurementsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetHostMeasurementsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call { + return &MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call{Call: _e.mock.On("GetHostMeasurementsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetHostMeasurementsApiParams)) *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetHostMeasurementsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call) Return(_a0 admin.GetHostMeasurementsApiRequest) *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetHostMeasurementsApiParams) admin.GetHostMeasurementsApiRequest) *MonitoringAndLogsApi_GetHostMeasurementsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexMetrics provides a mock function with given fields: ctx, processId, indexName, databaseName, collectionName, groupId +func (_m *MonitoringAndLogsApi) GetIndexMetrics(ctx context.Context, processId string, indexName string, databaseName string, collectionName string, groupId string) admin.GetIndexMetricsApiRequest { + ret := _m.Called(ctx, processId, indexName, databaseName, collectionName, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetIndexMetrics") + } + + var r0 admin.GetIndexMetricsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) admin.GetIndexMetricsApiRequest); ok { + r0 = rf(ctx, processId, indexName, databaseName, collectionName, groupId) + } else { + r0 = ret.Get(0).(admin.GetIndexMetricsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetIndexMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexMetrics' +type MonitoringAndLogsApi_GetIndexMetrics_Call struct { + *mock.Call +} + +// GetIndexMetrics is a helper method to define mock.On call +// - ctx context.Context +// - processId string +// - indexName string +// - databaseName string +// - collectionName string +// - groupId string +func (_e *MonitoringAndLogsApi_Expecter) GetIndexMetrics(ctx interface{}, processId interface{}, indexName interface{}, databaseName interface{}, collectionName interface{}, groupId interface{}) *MonitoringAndLogsApi_GetIndexMetrics_Call { + return &MonitoringAndLogsApi_GetIndexMetrics_Call{Call: _e.mock.On("GetIndexMetrics", ctx, processId, indexName, databaseName, collectionName, groupId)} +} + +func (_c *MonitoringAndLogsApi_GetIndexMetrics_Call) Run(run func(ctx context.Context, processId string, indexName string, databaseName string, collectionName string, groupId string)) *MonitoringAndLogsApi_GetIndexMetrics_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), args[5].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetrics_Call) Return(_a0 admin.GetIndexMetricsApiRequest) *MonitoringAndLogsApi_GetIndexMetrics_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetrics_Call) RunAndReturn(run func(context.Context, string, string, string, string, string) admin.GetIndexMetricsApiRequest) *MonitoringAndLogsApi_GetIndexMetrics_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexMetricsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetIndexMetricsExecute(r admin.GetIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetIndexMetricsExecute") + } + + var r0 *admin.MeasurementsIndexes + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetIndexMetricsApiRequest) *admin.MeasurementsIndexes); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MeasurementsIndexes) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetIndexMetricsApiRequest) *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.GetIndexMetricsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetIndexMetricsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexMetricsExecute' +type MonitoringAndLogsApi_GetIndexMetricsExecute_Call struct { + *mock.Call +} + +// GetIndexMetricsExecute is a helper method to define mock.On call +// - r admin.GetIndexMetricsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetIndexMetricsExecute(r interface{}) *MonitoringAndLogsApi_GetIndexMetricsExecute_Call { + return &MonitoringAndLogsApi_GetIndexMetricsExecute_Call{Call: _e.mock.On("GetIndexMetricsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsExecute_Call) Run(run func(r admin.GetIndexMetricsApiRequest)) *MonitoringAndLogsApi_GetIndexMetricsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetIndexMetricsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsExecute_Call) Return(_a0 *admin.MeasurementsIndexes, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetIndexMetricsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsExecute_Call) RunAndReturn(run func(admin.GetIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error)) *MonitoringAndLogsApi_GetIndexMetricsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetIndexMetricsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetIndexMetricsWithParams(ctx context.Context, args *admin.GetIndexMetricsApiParams) admin.GetIndexMetricsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetIndexMetricsWithParams") + } + + var r0 admin.GetIndexMetricsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetIndexMetricsApiParams) admin.GetIndexMetricsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetIndexMetricsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetIndexMetricsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexMetricsWithParams' +type MonitoringAndLogsApi_GetIndexMetricsWithParams_Call struct { + *mock.Call +} + +// GetIndexMetricsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetIndexMetricsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetIndexMetricsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call { + return &MonitoringAndLogsApi_GetIndexMetricsWithParams_Call{Call: _e.mock.On("GetIndexMetricsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetIndexMetricsApiParams)) *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetIndexMetricsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call) Return(_a0 admin.GetIndexMetricsApiRequest) *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetIndexMetricsApiParams) admin.GetIndexMetricsApiRequest) *MonitoringAndLogsApi_GetIndexMetricsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetMeasurements provides a mock function with given fields: ctx, processId, groupId +func (_m *MonitoringAndLogsApi) GetMeasurements(ctx context.Context, processId string, groupId string) admin.GetMeasurementsApiRequest { + ret := _m.Called(ctx, processId, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetMeasurements") + } + + var r0 admin.GetMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetMeasurementsApiRequest); ok { + r0 = rf(ctx, processId, groupId) + } else { + r0 = ret.Get(0).(admin.GetMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetMeasurements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasurements' +type MonitoringAndLogsApi_GetMeasurements_Call struct { + *mock.Call +} + +// GetMeasurements is a helper method to define mock.On call +// - ctx context.Context +// - processId string +// - groupId string +func (_e *MonitoringAndLogsApi_Expecter) GetMeasurements(ctx interface{}, processId interface{}, groupId interface{}) *MonitoringAndLogsApi_GetMeasurements_Call { + return &MonitoringAndLogsApi_GetMeasurements_Call{Call: _e.mock.On("GetMeasurements", ctx, processId, groupId)} +} + +func (_c *MonitoringAndLogsApi_GetMeasurements_Call) Run(run func(ctx context.Context, processId string, groupId string)) *MonitoringAndLogsApi_GetMeasurements_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurements_Call) Return(_a0 admin.GetMeasurementsApiRequest) *MonitoringAndLogsApi_GetMeasurements_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurements_Call) RunAndReturn(run func(context.Context, string, string) admin.GetMeasurementsApiRequest) *MonitoringAndLogsApi_GetMeasurements_Call { + _c.Call.Return(run) + return _c +} + +// GetMeasurementsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) GetMeasurementsExecute(r admin.GetMeasurementsApiRequest) (*admin.MeasurementsNonIndex, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetMeasurementsExecute") + } + + var r0 *admin.MeasurementsNonIndex + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetMeasurementsApiRequest) (*admin.MeasurementsNonIndex, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetMeasurementsApiRequest) *admin.MeasurementsNonIndex); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MeasurementsNonIndex) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetMeasurementsApiRequest) *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.GetMeasurementsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_GetMeasurementsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasurementsExecute' +type MonitoringAndLogsApi_GetMeasurementsExecute_Call struct { + *mock.Call +} + +// GetMeasurementsExecute is a helper method to define mock.On call +// - r admin.GetMeasurementsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) GetMeasurementsExecute(r interface{}) *MonitoringAndLogsApi_GetMeasurementsExecute_Call { + return &MonitoringAndLogsApi_GetMeasurementsExecute_Call{Call: _e.mock.On("GetMeasurementsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsExecute_Call) Run(run func(r admin.GetMeasurementsApiRequest)) *MonitoringAndLogsApi_GetMeasurementsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetMeasurementsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsExecute_Call) Return(_a0 *admin.MeasurementsNonIndex, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_GetMeasurementsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsExecute_Call) RunAndReturn(run func(admin.GetMeasurementsApiRequest) (*admin.MeasurementsNonIndex, *http.Response, error)) *MonitoringAndLogsApi_GetMeasurementsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetMeasurementsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) GetMeasurementsWithParams(ctx context.Context, args *admin.GetMeasurementsApiParams) admin.GetMeasurementsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetMeasurementsWithParams") + } + + var r0 admin.GetMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetMeasurementsApiParams) admin.GetMeasurementsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_GetMeasurementsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasurementsWithParams' +type MonitoringAndLogsApi_GetMeasurementsWithParams_Call struct { + *mock.Call +} + +// GetMeasurementsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetMeasurementsApiParams +func (_e *MonitoringAndLogsApi_Expecter) GetMeasurementsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_GetMeasurementsWithParams_Call { + return &MonitoringAndLogsApi_GetMeasurementsWithParams_Call{Call: _e.mock.On("GetMeasurementsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetMeasurementsApiParams)) *MonitoringAndLogsApi_GetMeasurementsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetMeasurementsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsWithParams_Call) Return(_a0 admin.GetMeasurementsApiRequest) *MonitoringAndLogsApi_GetMeasurementsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_GetMeasurementsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetMeasurementsApiParams) admin.GetMeasurementsApiRequest) *MonitoringAndLogsApi_GetMeasurementsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListAtlasProcesses provides a mock function with given fields: ctx, groupId +func (_m *MonitoringAndLogsApi) ListAtlasProcesses(ctx context.Context, groupId string) admin.ListAtlasProcessesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListAtlasProcesses") + } + + var r0 admin.ListAtlasProcessesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListAtlasProcessesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListAtlasProcessesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListAtlasProcesses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasProcesses' +type MonitoringAndLogsApi_ListAtlasProcesses_Call struct { + *mock.Call +} + +// ListAtlasProcesses is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *MonitoringAndLogsApi_Expecter) ListAtlasProcesses(ctx interface{}, groupId interface{}) *MonitoringAndLogsApi_ListAtlasProcesses_Call { + return &MonitoringAndLogsApi_ListAtlasProcesses_Call{Call: _e.mock.On("ListAtlasProcesses", ctx, groupId)} +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcesses_Call) Run(run func(ctx context.Context, groupId string)) *MonitoringAndLogsApi_ListAtlasProcesses_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcesses_Call) Return(_a0 admin.ListAtlasProcessesApiRequest) *MonitoringAndLogsApi_ListAtlasProcesses_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcesses_Call) RunAndReturn(run func(context.Context, string) admin.ListAtlasProcessesApiRequest) *MonitoringAndLogsApi_ListAtlasProcesses_Call { + _c.Call.Return(run) + return _c +} + +// ListAtlasProcessesExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListAtlasProcessesExecute(r admin.ListAtlasProcessesApiRequest) (*admin.PaginatedHostViewAtlas, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListAtlasProcessesExecute") + } + + var r0 *admin.PaginatedHostViewAtlas + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListAtlasProcessesApiRequest) (*admin.PaginatedHostViewAtlas, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListAtlasProcessesApiRequest) *admin.PaginatedHostViewAtlas); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedHostViewAtlas) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListAtlasProcessesApiRequest) *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.ListAtlasProcessesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListAtlasProcessesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasProcessesExecute' +type MonitoringAndLogsApi_ListAtlasProcessesExecute_Call struct { + *mock.Call +} + +// ListAtlasProcessesExecute is a helper method to define mock.On call +// - r admin.ListAtlasProcessesApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListAtlasProcessesExecute(r interface{}) *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call { + return &MonitoringAndLogsApi_ListAtlasProcessesExecute_Call{Call: _e.mock.On("ListAtlasProcessesExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call) Run(run func(r admin.ListAtlasProcessesApiRequest)) *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListAtlasProcessesApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call) Return(_a0 *admin.PaginatedHostViewAtlas, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call) RunAndReturn(run func(admin.ListAtlasProcessesApiRequest) (*admin.PaginatedHostViewAtlas, *http.Response, error)) *MonitoringAndLogsApi_ListAtlasProcessesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListAtlasProcessesWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListAtlasProcessesWithParams(ctx context.Context, args *admin.ListAtlasProcessesApiParams) admin.ListAtlasProcessesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListAtlasProcessesWithParams") + } + + var r0 admin.ListAtlasProcessesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListAtlasProcessesApiParams) admin.ListAtlasProcessesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListAtlasProcessesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAtlasProcessesWithParams' +type MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call struct { + *mock.Call +} + +// ListAtlasProcessesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListAtlasProcessesApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListAtlasProcessesWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call { + return &MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call{Call: _e.mock.On("ListAtlasProcessesWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListAtlasProcessesApiParams)) *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListAtlasProcessesApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call) Return(_a0 admin.ListAtlasProcessesApiRequest) *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListAtlasProcessesApiParams) admin.ListAtlasProcessesApiRequest) *MonitoringAndLogsApi_ListAtlasProcessesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabases provides a mock function with given fields: ctx, groupId, processId +func (_m *MonitoringAndLogsApi) ListDatabases(ctx context.Context, groupId string, processId string) admin.ListDatabasesApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListDatabases") + } + + var r0 admin.ListDatabasesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListDatabasesApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListDatabasesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDatabases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabases' +type MonitoringAndLogsApi_ListDatabases_Call struct { + *mock.Call +} + +// ListDatabases is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) ListDatabases(ctx interface{}, groupId interface{}, processId interface{}) *MonitoringAndLogsApi_ListDatabases_Call { + return &MonitoringAndLogsApi_ListDatabases_Call{Call: _e.mock.On("ListDatabases", ctx, groupId, processId)} +} + +func (_c *MonitoringAndLogsApi_ListDatabases_Call) Run(run func(ctx context.Context, groupId string, processId string)) *MonitoringAndLogsApi_ListDatabases_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabases_Call) Return(_a0 admin.ListDatabasesApiRequest) *MonitoringAndLogsApi_ListDatabases_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabases_Call) RunAndReturn(run func(context.Context, string, string) admin.ListDatabasesApiRequest) *MonitoringAndLogsApi_ListDatabases_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabasesExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListDatabasesExecute(r admin.ListDatabasesApiRequest) (*admin.PaginatedDatabase, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDatabasesExecute") + } + + var r0 *admin.PaginatedDatabase + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDatabasesApiRequest) (*admin.PaginatedDatabase, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDatabasesApiRequest) *admin.PaginatedDatabase); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedDatabase) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDatabasesApiRequest) *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.ListDatabasesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListDatabasesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabasesExecute' +type MonitoringAndLogsApi_ListDatabasesExecute_Call struct { + *mock.Call +} + +// ListDatabasesExecute is a helper method to define mock.On call +// - r admin.ListDatabasesApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListDatabasesExecute(r interface{}) *MonitoringAndLogsApi_ListDatabasesExecute_Call { + return &MonitoringAndLogsApi_ListDatabasesExecute_Call{Call: _e.mock.On("ListDatabasesExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListDatabasesExecute_Call) Run(run func(r admin.ListDatabasesApiRequest)) *MonitoringAndLogsApi_ListDatabasesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDatabasesApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabasesExecute_Call) Return(_a0 *admin.PaginatedDatabase, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListDatabasesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabasesExecute_Call) RunAndReturn(run func(admin.ListDatabasesApiRequest) (*admin.PaginatedDatabase, *http.Response, error)) *MonitoringAndLogsApi_ListDatabasesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabasesWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListDatabasesWithParams(ctx context.Context, args *admin.ListDatabasesApiParams) admin.ListDatabasesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDatabasesWithParams") + } + + var r0 admin.ListDatabasesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDatabasesApiParams) admin.ListDatabasesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDatabasesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDatabasesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabasesWithParams' +type MonitoringAndLogsApi_ListDatabasesWithParams_Call struct { + *mock.Call +} + +// ListDatabasesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDatabasesApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListDatabasesWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListDatabasesWithParams_Call { + return &MonitoringAndLogsApi_ListDatabasesWithParams_Call{Call: _e.mock.On("ListDatabasesWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListDatabasesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDatabasesApiParams)) *MonitoringAndLogsApi_ListDatabasesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDatabasesApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabasesWithParams_Call) Return(_a0 admin.ListDatabasesApiRequest) *MonitoringAndLogsApi_ListDatabasesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDatabasesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDatabasesApiParams) admin.ListDatabasesApiRequest) *MonitoringAndLogsApi_ListDatabasesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskMeasurements provides a mock function with given fields: ctx, partitionName, groupId, processId +func (_m *MonitoringAndLogsApi) ListDiskMeasurements(ctx context.Context, partitionName string, groupId string, processId string) admin.ListDiskMeasurementsApiRequest { + ret := _m.Called(ctx, partitionName, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListDiskMeasurements") + } + + var r0 admin.ListDiskMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.ListDiskMeasurementsApiRequest); ok { + r0 = rf(ctx, partitionName, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListDiskMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDiskMeasurements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskMeasurements' +type MonitoringAndLogsApi_ListDiskMeasurements_Call struct { + *mock.Call +} + +// ListDiskMeasurements is a helper method to define mock.On call +// - ctx context.Context +// - partitionName string +// - groupId string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) ListDiskMeasurements(ctx interface{}, partitionName interface{}, groupId interface{}, processId interface{}) *MonitoringAndLogsApi_ListDiskMeasurements_Call { + return &MonitoringAndLogsApi_ListDiskMeasurements_Call{Call: _e.mock.On("ListDiskMeasurements", ctx, partitionName, groupId, processId)} +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurements_Call) Run(run func(ctx context.Context, partitionName string, groupId string, processId string)) *MonitoringAndLogsApi_ListDiskMeasurements_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 *MonitoringAndLogsApi_ListDiskMeasurements_Call) Return(_a0 admin.ListDiskMeasurementsApiRequest) *MonitoringAndLogsApi_ListDiskMeasurements_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurements_Call) RunAndReturn(run func(context.Context, string, string, string) admin.ListDiskMeasurementsApiRequest) *MonitoringAndLogsApi_ListDiskMeasurements_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskMeasurementsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListDiskMeasurementsExecute(r admin.ListDiskMeasurementsApiRequest) (*admin.MeasurementDiskPartition, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDiskMeasurementsExecute") + } + + var r0 *admin.MeasurementDiskPartition + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDiskMeasurementsApiRequest) (*admin.MeasurementDiskPartition, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDiskMeasurementsApiRequest) *admin.MeasurementDiskPartition); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MeasurementDiskPartition) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDiskMeasurementsApiRequest) *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.ListDiskMeasurementsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskMeasurementsExecute' +type MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call struct { + *mock.Call +} + +// ListDiskMeasurementsExecute is a helper method to define mock.On call +// - r admin.ListDiskMeasurementsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListDiskMeasurementsExecute(r interface{}) *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call { + return &MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call{Call: _e.mock.On("ListDiskMeasurementsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call) Run(run func(r admin.ListDiskMeasurementsApiRequest)) *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDiskMeasurementsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call) Return(_a0 *admin.MeasurementDiskPartition, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call) RunAndReturn(run func(admin.ListDiskMeasurementsApiRequest) (*admin.MeasurementDiskPartition, *http.Response, error)) *MonitoringAndLogsApi_ListDiskMeasurementsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskMeasurementsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListDiskMeasurementsWithParams(ctx context.Context, args *admin.ListDiskMeasurementsApiParams) admin.ListDiskMeasurementsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDiskMeasurementsWithParams") + } + + var r0 admin.ListDiskMeasurementsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDiskMeasurementsApiParams) admin.ListDiskMeasurementsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDiskMeasurementsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskMeasurementsWithParams' +type MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call struct { + *mock.Call +} + +// ListDiskMeasurementsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDiskMeasurementsApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListDiskMeasurementsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call { + return &MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call{Call: _e.mock.On("ListDiskMeasurementsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDiskMeasurementsApiParams)) *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDiskMeasurementsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call) Return(_a0 admin.ListDiskMeasurementsApiRequest) *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDiskMeasurementsApiParams) admin.ListDiskMeasurementsApiRequest) *MonitoringAndLogsApi_ListDiskMeasurementsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskPartitions provides a mock function with given fields: ctx, groupId, processId +func (_m *MonitoringAndLogsApi) ListDiskPartitions(ctx context.Context, groupId string, processId string) admin.ListDiskPartitionsApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListDiskPartitions") + } + + var r0 admin.ListDiskPartitionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListDiskPartitionsApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListDiskPartitionsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDiskPartitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskPartitions' +type MonitoringAndLogsApi_ListDiskPartitions_Call struct { + *mock.Call +} + +// ListDiskPartitions is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *MonitoringAndLogsApi_Expecter) ListDiskPartitions(ctx interface{}, groupId interface{}, processId interface{}) *MonitoringAndLogsApi_ListDiskPartitions_Call { + return &MonitoringAndLogsApi_ListDiskPartitions_Call{Call: _e.mock.On("ListDiskPartitions", ctx, groupId, processId)} +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitions_Call) Run(run func(ctx context.Context, groupId string, processId string)) *MonitoringAndLogsApi_ListDiskPartitions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitions_Call) Return(_a0 admin.ListDiskPartitionsApiRequest) *MonitoringAndLogsApi_ListDiskPartitions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitions_Call) RunAndReturn(run func(context.Context, string, string) admin.ListDiskPartitionsApiRequest) *MonitoringAndLogsApi_ListDiskPartitions_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskPartitionsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListDiskPartitionsExecute(r admin.ListDiskPartitionsApiRequest) (*admin.PaginatedDiskPartition, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDiskPartitionsExecute") + } + + var r0 *admin.PaginatedDiskPartition + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDiskPartitionsApiRequest) (*admin.PaginatedDiskPartition, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDiskPartitionsApiRequest) *admin.PaginatedDiskPartition); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedDiskPartition) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDiskPartitionsApiRequest) *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.ListDiskPartitionsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListDiskPartitionsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskPartitionsExecute' +type MonitoringAndLogsApi_ListDiskPartitionsExecute_Call struct { + *mock.Call +} + +// ListDiskPartitionsExecute is a helper method to define mock.On call +// - r admin.ListDiskPartitionsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListDiskPartitionsExecute(r interface{}) *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call { + return &MonitoringAndLogsApi_ListDiskPartitionsExecute_Call{Call: _e.mock.On("ListDiskPartitionsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call) Run(run func(r admin.ListDiskPartitionsApiRequest)) *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDiskPartitionsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call) Return(_a0 *admin.PaginatedDiskPartition, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call) RunAndReturn(run func(admin.ListDiskPartitionsApiRequest) (*admin.PaginatedDiskPartition, *http.Response, error)) *MonitoringAndLogsApi_ListDiskPartitionsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDiskPartitionsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListDiskPartitionsWithParams(ctx context.Context, args *admin.ListDiskPartitionsApiParams) admin.ListDiskPartitionsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDiskPartitionsWithParams") + } + + var r0 admin.ListDiskPartitionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDiskPartitionsApiParams) admin.ListDiskPartitionsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDiskPartitionsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiskPartitionsWithParams' +type MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call struct { + *mock.Call +} + +// ListDiskPartitionsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDiskPartitionsApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListDiskPartitionsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call { + return &MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call{Call: _e.mock.On("ListDiskPartitionsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDiskPartitionsApiParams)) *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDiskPartitionsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call) Return(_a0 admin.ListDiskPartitionsApiRequest) *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDiskPartitionsApiParams) admin.ListDiskPartitionsApiRequest) *MonitoringAndLogsApi_ListDiskPartitionsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListIndexMetrics provides a mock function with given fields: ctx, processId, databaseName, collectionName, groupId +func (_m *MonitoringAndLogsApi) ListIndexMetrics(ctx context.Context, processId string, databaseName string, collectionName string, groupId string) admin.ListIndexMetricsApiRequest { + ret := _m.Called(ctx, processId, databaseName, collectionName, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListIndexMetrics") + } + + var r0 admin.ListIndexMetricsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) admin.ListIndexMetricsApiRequest); ok { + r0 = rf(ctx, processId, databaseName, collectionName, groupId) + } else { + r0 = ret.Get(0).(admin.ListIndexMetricsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListIndexMetrics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIndexMetrics' +type MonitoringAndLogsApi_ListIndexMetrics_Call struct { + *mock.Call +} + +// ListIndexMetrics is a helper method to define mock.On call +// - ctx context.Context +// - processId string +// - databaseName string +// - collectionName string +// - groupId string +func (_e *MonitoringAndLogsApi_Expecter) ListIndexMetrics(ctx interface{}, processId interface{}, databaseName interface{}, collectionName interface{}, groupId interface{}) *MonitoringAndLogsApi_ListIndexMetrics_Call { + return &MonitoringAndLogsApi_ListIndexMetrics_Call{Call: _e.mock.On("ListIndexMetrics", ctx, processId, databaseName, collectionName, groupId)} +} + +func (_c *MonitoringAndLogsApi_ListIndexMetrics_Call) Run(run func(ctx context.Context, processId string, databaseName string, collectionName string, groupId string)) *MonitoringAndLogsApi_ListIndexMetrics_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 *MonitoringAndLogsApi_ListIndexMetrics_Call) Return(_a0 admin.ListIndexMetricsApiRequest) *MonitoringAndLogsApi_ListIndexMetrics_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListIndexMetrics_Call) RunAndReturn(run func(context.Context, string, string, string, string) admin.ListIndexMetricsApiRequest) *MonitoringAndLogsApi_ListIndexMetrics_Call { + _c.Call.Return(run) + return _c +} + +// ListIndexMetricsExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListIndexMetricsExecute(r admin.ListIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListIndexMetricsExecute") + } + + var r0 *admin.MeasurementsIndexes + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListIndexMetricsApiRequest) *admin.MeasurementsIndexes); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.MeasurementsIndexes) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListIndexMetricsApiRequest) *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.ListIndexMetricsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListIndexMetricsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIndexMetricsExecute' +type MonitoringAndLogsApi_ListIndexMetricsExecute_Call struct { + *mock.Call +} + +// ListIndexMetricsExecute is a helper method to define mock.On call +// - r admin.ListIndexMetricsApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListIndexMetricsExecute(r interface{}) *MonitoringAndLogsApi_ListIndexMetricsExecute_Call { + return &MonitoringAndLogsApi_ListIndexMetricsExecute_Call{Call: _e.mock.On("ListIndexMetricsExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsExecute_Call) Run(run func(r admin.ListIndexMetricsApiRequest)) *MonitoringAndLogsApi_ListIndexMetricsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListIndexMetricsApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsExecute_Call) Return(_a0 *admin.MeasurementsIndexes, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListIndexMetricsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsExecute_Call) RunAndReturn(run func(admin.ListIndexMetricsApiRequest) (*admin.MeasurementsIndexes, *http.Response, error)) *MonitoringAndLogsApi_ListIndexMetricsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListIndexMetricsWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListIndexMetricsWithParams(ctx context.Context, args *admin.ListIndexMetricsApiParams) admin.ListIndexMetricsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListIndexMetricsWithParams") + } + + var r0 admin.ListIndexMetricsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListIndexMetricsApiParams) admin.ListIndexMetricsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListIndexMetricsApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListIndexMetricsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListIndexMetricsWithParams' +type MonitoringAndLogsApi_ListIndexMetricsWithParams_Call struct { + *mock.Call +} + +// ListIndexMetricsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListIndexMetricsApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListIndexMetricsWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call { + return &MonitoringAndLogsApi_ListIndexMetricsWithParams_Call{Call: _e.mock.On("ListIndexMetricsWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListIndexMetricsApiParams)) *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListIndexMetricsApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call) Return(_a0 admin.ListIndexMetricsApiRequest) *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListIndexMetricsApiParams) admin.ListIndexMetricsApiRequest) *MonitoringAndLogsApi_ListIndexMetricsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListMetricTypes provides a mock function with given fields: ctx, processId, groupId +func (_m *MonitoringAndLogsApi) ListMetricTypes(ctx context.Context, processId string, groupId string) admin.ListMetricTypesApiRequest { + ret := _m.Called(ctx, processId, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListMetricTypes") + } + + var r0 admin.ListMetricTypesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListMetricTypesApiRequest); ok { + r0 = rf(ctx, processId, groupId) + } else { + r0 = ret.Get(0).(admin.ListMetricTypesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListMetricTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMetricTypes' +type MonitoringAndLogsApi_ListMetricTypes_Call struct { + *mock.Call +} + +// ListMetricTypes is a helper method to define mock.On call +// - ctx context.Context +// - processId string +// - groupId string +func (_e *MonitoringAndLogsApi_Expecter) ListMetricTypes(ctx interface{}, processId interface{}, groupId interface{}) *MonitoringAndLogsApi_ListMetricTypes_Call { + return &MonitoringAndLogsApi_ListMetricTypes_Call{Call: _e.mock.On("ListMetricTypes", ctx, processId, groupId)} +} + +func (_c *MonitoringAndLogsApi_ListMetricTypes_Call) Run(run func(ctx context.Context, processId string, groupId string)) *MonitoringAndLogsApi_ListMetricTypes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypes_Call) Return(_a0 admin.ListMetricTypesApiRequest) *MonitoringAndLogsApi_ListMetricTypes_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypes_Call) RunAndReturn(run func(context.Context, string, string) admin.ListMetricTypesApiRequest) *MonitoringAndLogsApi_ListMetricTypes_Call { + _c.Call.Return(run) + return _c +} + +// ListMetricTypesExecute provides a mock function with given fields: r +func (_m *MonitoringAndLogsApi) ListMetricTypesExecute(r admin.ListMetricTypesApiRequest) (*admin.CloudSearchMetrics, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListMetricTypesExecute") + } + + var r0 *admin.CloudSearchMetrics + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListMetricTypesApiRequest) (*admin.CloudSearchMetrics, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListMetricTypesApiRequest) *admin.CloudSearchMetrics); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudSearchMetrics) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListMetricTypesApiRequest) *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.ListMetricTypesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MonitoringAndLogsApi_ListMetricTypesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMetricTypesExecute' +type MonitoringAndLogsApi_ListMetricTypesExecute_Call struct { + *mock.Call +} + +// ListMetricTypesExecute is a helper method to define mock.On call +// - r admin.ListMetricTypesApiRequest +func (_e *MonitoringAndLogsApi_Expecter) ListMetricTypesExecute(r interface{}) *MonitoringAndLogsApi_ListMetricTypesExecute_Call { + return &MonitoringAndLogsApi_ListMetricTypesExecute_Call{Call: _e.mock.On("ListMetricTypesExecute", r)} +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesExecute_Call) Run(run func(r admin.ListMetricTypesApiRequest)) *MonitoringAndLogsApi_ListMetricTypesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListMetricTypesApiRequest)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesExecute_Call) Return(_a0 *admin.CloudSearchMetrics, _a1 *http.Response, _a2 error) *MonitoringAndLogsApi_ListMetricTypesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesExecute_Call) RunAndReturn(run func(admin.ListMetricTypesApiRequest) (*admin.CloudSearchMetrics, *http.Response, error)) *MonitoringAndLogsApi_ListMetricTypesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListMetricTypesWithParams provides a mock function with given fields: ctx, args +func (_m *MonitoringAndLogsApi) ListMetricTypesWithParams(ctx context.Context, args *admin.ListMetricTypesApiParams) admin.ListMetricTypesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListMetricTypesWithParams") + } + + var r0 admin.ListMetricTypesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListMetricTypesApiParams) admin.ListMetricTypesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListMetricTypesApiRequest) + } + + return r0 +} + +// MonitoringAndLogsApi_ListMetricTypesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMetricTypesWithParams' +type MonitoringAndLogsApi_ListMetricTypesWithParams_Call struct { + *mock.Call +} + +// ListMetricTypesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListMetricTypesApiParams +func (_e *MonitoringAndLogsApi_Expecter) ListMetricTypesWithParams(ctx interface{}, args interface{}) *MonitoringAndLogsApi_ListMetricTypesWithParams_Call { + return &MonitoringAndLogsApi_ListMetricTypesWithParams_Call{Call: _e.mock.On("ListMetricTypesWithParams", ctx, args)} +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListMetricTypesApiParams)) *MonitoringAndLogsApi_ListMetricTypesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListMetricTypesApiParams)) + }) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesWithParams_Call) Return(_a0 admin.ListMetricTypesApiRequest) *MonitoringAndLogsApi_ListMetricTypesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MonitoringAndLogsApi_ListMetricTypesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListMetricTypesApiParams) admin.ListMetricTypesApiRequest) *MonitoringAndLogsApi_ListMetricTypesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewMonitoringAndLogsApi creates a new instance of MonitoringAndLogsApi. 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 NewMonitoringAndLogsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *MonitoringAndLogsApi { + mock := &MonitoringAndLogsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/network_peering_api.go b/mockadmin/network_peering_api.go new file mode 100644 index 000000000..64139f8f3 --- /dev/null +++ b/mockadmin/network_peering_api.go @@ -0,0 +1,2144 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// NetworkPeeringApi is an autogenerated mock type for the NetworkPeeringApi type +type NetworkPeeringApi struct { + mock.Mock +} + +type NetworkPeeringApi_Expecter struct { + mock *mock.Mock +} + +func (_m *NetworkPeeringApi) EXPECT() *NetworkPeeringApi_Expecter { + return &NetworkPeeringApi_Expecter{mock: &_m.Mock} +} + +// CreatePeeringConnection provides a mock function with given fields: ctx, groupId, baseNetworkPeeringConnectionSettings +func (_m *NetworkPeeringApi) CreatePeeringConnection(ctx context.Context, groupId string, baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings) admin.CreatePeeringConnectionApiRequest { + ret := _m.Called(ctx, groupId, baseNetworkPeeringConnectionSettings) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringConnection") + } + + var r0 admin.CreatePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.BaseNetworkPeeringConnectionSettings) admin.CreatePeeringConnectionApiRequest); ok { + r0 = rf(ctx, groupId, baseNetworkPeeringConnectionSettings) + } else { + r0 = ret.Get(0).(admin.CreatePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_CreatePeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringConnection' +type NetworkPeeringApi_CreatePeeringConnection_Call struct { + *mock.Call +} + +// CreatePeeringConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings +func (_e *NetworkPeeringApi_Expecter) CreatePeeringConnection(ctx interface{}, groupId interface{}, baseNetworkPeeringConnectionSettings interface{}) *NetworkPeeringApi_CreatePeeringConnection_Call { + return &NetworkPeeringApi_CreatePeeringConnection_Call{Call: _e.mock.On("CreatePeeringConnection", ctx, groupId, baseNetworkPeeringConnectionSettings)} +} + +func (_c *NetworkPeeringApi_CreatePeeringConnection_Call) Run(run func(ctx context.Context, groupId string, baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings)) *NetworkPeeringApi_CreatePeeringConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.BaseNetworkPeeringConnectionSettings)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnection_Call) Return(_a0 admin.CreatePeeringConnectionApiRequest) *NetworkPeeringApi_CreatePeeringConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnection_Call) RunAndReturn(run func(context.Context, string, *admin.BaseNetworkPeeringConnectionSettings) admin.CreatePeeringConnectionApiRequest) *NetworkPeeringApi_CreatePeeringConnection_Call { + _c.Call.Return(run) + return _c +} + +// CreatePeeringConnectionExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) CreatePeeringConnectionExecute(r admin.CreatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringConnectionExecute") + } + + var r0 *admin.BaseNetworkPeeringConnectionSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePeeringConnectionApiRequest) *admin.BaseNetworkPeeringConnectionSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BaseNetworkPeeringConnectionSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePeeringConnectionApiRequest) *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.CreatePeeringConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_CreatePeeringConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringConnectionExecute' +type NetworkPeeringApi_CreatePeeringConnectionExecute_Call struct { + *mock.Call +} + +// CreatePeeringConnectionExecute is a helper method to define mock.On call +// - r admin.CreatePeeringConnectionApiRequest +func (_e *NetworkPeeringApi_Expecter) CreatePeeringConnectionExecute(r interface{}) *NetworkPeeringApi_CreatePeeringConnectionExecute_Call { + return &NetworkPeeringApi_CreatePeeringConnectionExecute_Call{Call: _e.mock.On("CreatePeeringConnectionExecute", r)} +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionExecute_Call) Run(run func(r admin.CreatePeeringConnectionApiRequest)) *NetworkPeeringApi_CreatePeeringConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePeeringConnectionApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionExecute_Call) Return(_a0 *admin.BaseNetworkPeeringConnectionSettings, _a1 *http.Response, _a2 error) *NetworkPeeringApi_CreatePeeringConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionExecute_Call) RunAndReturn(run func(admin.CreatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)) *NetworkPeeringApi_CreatePeeringConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePeeringConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) CreatePeeringConnectionWithParams(ctx context.Context, args *admin.CreatePeeringConnectionApiParams) admin.CreatePeeringConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringConnectionWithParams") + } + + var r0 admin.CreatePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePeeringConnectionApiParams) admin.CreatePeeringConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_CreatePeeringConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringConnectionWithParams' +type NetworkPeeringApi_CreatePeeringConnectionWithParams_Call struct { + *mock.Call +} + +// CreatePeeringConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePeeringConnectionApiParams +func (_e *NetworkPeeringApi_Expecter) CreatePeeringConnectionWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call { + return &NetworkPeeringApi_CreatePeeringConnectionWithParams_Call{Call: _e.mock.On("CreatePeeringConnectionWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePeeringConnectionApiParams)) *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePeeringConnectionApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call) Return(_a0 admin.CreatePeeringConnectionApiRequest) *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePeeringConnectionApiParams) admin.CreatePeeringConnectionApiRequest) *NetworkPeeringApi_CreatePeeringConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreatePeeringContainer provides a mock function with given fields: ctx, groupId, cloudProviderContainer +func (_m *NetworkPeeringApi) CreatePeeringContainer(ctx context.Context, groupId string, cloudProviderContainer *admin.CloudProviderContainer) admin.CreatePeeringContainerApiRequest { + ret := _m.Called(ctx, groupId, cloudProviderContainer) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringContainer") + } + + var r0 admin.CreatePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CloudProviderContainer) admin.CreatePeeringContainerApiRequest); ok { + r0 = rf(ctx, groupId, cloudProviderContainer) + } else { + r0 = ret.Get(0).(admin.CreatePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_CreatePeeringContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringContainer' +type NetworkPeeringApi_CreatePeeringContainer_Call struct { + *mock.Call +} + +// CreatePeeringContainer is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProviderContainer *admin.CloudProviderContainer +func (_e *NetworkPeeringApi_Expecter) CreatePeeringContainer(ctx interface{}, groupId interface{}, cloudProviderContainer interface{}) *NetworkPeeringApi_CreatePeeringContainer_Call { + return &NetworkPeeringApi_CreatePeeringContainer_Call{Call: _e.mock.On("CreatePeeringContainer", ctx, groupId, cloudProviderContainer)} +} + +func (_c *NetworkPeeringApi_CreatePeeringContainer_Call) Run(run func(ctx context.Context, groupId string, cloudProviderContainer *admin.CloudProviderContainer)) *NetworkPeeringApi_CreatePeeringContainer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CloudProviderContainer)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainer_Call) Return(_a0 admin.CreatePeeringContainerApiRequest) *NetworkPeeringApi_CreatePeeringContainer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainer_Call) RunAndReturn(run func(context.Context, string, *admin.CloudProviderContainer) admin.CreatePeeringContainerApiRequest) *NetworkPeeringApi_CreatePeeringContainer_Call { + _c.Call.Return(run) + return _c +} + +// CreatePeeringContainerExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) CreatePeeringContainerExecute(r admin.CreatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringContainerExecute") + } + + var r0 *admin.CloudProviderContainer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePeeringContainerApiRequest) *admin.CloudProviderContainer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderContainer) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePeeringContainerApiRequest) *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.CreatePeeringContainerApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_CreatePeeringContainerExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringContainerExecute' +type NetworkPeeringApi_CreatePeeringContainerExecute_Call struct { + *mock.Call +} + +// CreatePeeringContainerExecute is a helper method to define mock.On call +// - r admin.CreatePeeringContainerApiRequest +func (_e *NetworkPeeringApi_Expecter) CreatePeeringContainerExecute(r interface{}) *NetworkPeeringApi_CreatePeeringContainerExecute_Call { + return &NetworkPeeringApi_CreatePeeringContainerExecute_Call{Call: _e.mock.On("CreatePeeringContainerExecute", r)} +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerExecute_Call) Run(run func(r admin.CreatePeeringContainerApiRequest)) *NetworkPeeringApi_CreatePeeringContainerExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePeeringContainerApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerExecute_Call) Return(_a0 *admin.CloudProviderContainer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_CreatePeeringContainerExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerExecute_Call) RunAndReturn(run func(admin.CreatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)) *NetworkPeeringApi_CreatePeeringContainerExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePeeringContainerWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) CreatePeeringContainerWithParams(ctx context.Context, args *admin.CreatePeeringContainerApiParams) admin.CreatePeeringContainerApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePeeringContainerWithParams") + } + + var r0 admin.CreatePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePeeringContainerApiParams) admin.CreatePeeringContainerApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_CreatePeeringContainerWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePeeringContainerWithParams' +type NetworkPeeringApi_CreatePeeringContainerWithParams_Call struct { + *mock.Call +} + +// CreatePeeringContainerWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePeeringContainerApiParams +func (_e *NetworkPeeringApi_Expecter) CreatePeeringContainerWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_CreatePeeringContainerWithParams_Call { + return &NetworkPeeringApi_CreatePeeringContainerWithParams_Call{Call: _e.mock.On("CreatePeeringContainerWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePeeringContainerApiParams)) *NetworkPeeringApi_CreatePeeringContainerWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePeeringContainerApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerWithParams_Call) Return(_a0 admin.CreatePeeringContainerApiRequest) *NetworkPeeringApi_CreatePeeringContainerWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_CreatePeeringContainerWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePeeringContainerApiParams) admin.CreatePeeringContainerApiRequest) *NetworkPeeringApi_CreatePeeringContainerWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringConnection provides a mock function with given fields: ctx, groupId, peerId +func (_m *NetworkPeeringApi) DeletePeeringConnection(ctx context.Context, groupId string, peerId string) admin.DeletePeeringConnectionApiRequest { + ret := _m.Called(ctx, groupId, peerId) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringConnection") + } + + var r0 admin.DeletePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeletePeeringConnectionApiRequest); ok { + r0 = rf(ctx, groupId, peerId) + } else { + r0 = ret.Get(0).(admin.DeletePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DeletePeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringConnection' +type NetworkPeeringApi_DeletePeeringConnection_Call struct { + *mock.Call +} + +// DeletePeeringConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - peerId string +func (_e *NetworkPeeringApi_Expecter) DeletePeeringConnection(ctx interface{}, groupId interface{}, peerId interface{}) *NetworkPeeringApi_DeletePeeringConnection_Call { + return &NetworkPeeringApi_DeletePeeringConnection_Call{Call: _e.mock.On("DeletePeeringConnection", ctx, groupId, peerId)} +} + +func (_c *NetworkPeeringApi_DeletePeeringConnection_Call) Run(run func(ctx context.Context, groupId string, peerId string)) *NetworkPeeringApi_DeletePeeringConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnection_Call) Return(_a0 admin.DeletePeeringConnectionApiRequest) *NetworkPeeringApi_DeletePeeringConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnection_Call) RunAndReturn(run func(context.Context, string, string) admin.DeletePeeringConnectionApiRequest) *NetworkPeeringApi_DeletePeeringConnection_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringConnectionExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) DeletePeeringConnectionExecute(r admin.DeletePeeringConnectionApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringConnectionExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePeeringConnectionApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePeeringConnectionApiRequest) 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.DeletePeeringConnectionApiRequest) *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.DeletePeeringConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_DeletePeeringConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringConnectionExecute' +type NetworkPeeringApi_DeletePeeringConnectionExecute_Call struct { + *mock.Call +} + +// DeletePeeringConnectionExecute is a helper method to define mock.On call +// - r admin.DeletePeeringConnectionApiRequest +func (_e *NetworkPeeringApi_Expecter) DeletePeeringConnectionExecute(r interface{}) *NetworkPeeringApi_DeletePeeringConnectionExecute_Call { + return &NetworkPeeringApi_DeletePeeringConnectionExecute_Call{Call: _e.mock.On("DeletePeeringConnectionExecute", r)} +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionExecute_Call) Run(run func(r admin.DeletePeeringConnectionApiRequest)) *NetworkPeeringApi_DeletePeeringConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePeeringConnectionApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *NetworkPeeringApi_DeletePeeringConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionExecute_Call) RunAndReturn(run func(admin.DeletePeeringConnectionApiRequest) (map[string]interface{}, *http.Response, error)) *NetworkPeeringApi_DeletePeeringConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) DeletePeeringConnectionWithParams(ctx context.Context, args *admin.DeletePeeringConnectionApiParams) admin.DeletePeeringConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringConnectionWithParams") + } + + var r0 admin.DeletePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePeeringConnectionApiParams) admin.DeletePeeringConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DeletePeeringConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringConnectionWithParams' +type NetworkPeeringApi_DeletePeeringConnectionWithParams_Call struct { + *mock.Call +} + +// DeletePeeringConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePeeringConnectionApiParams +func (_e *NetworkPeeringApi_Expecter) DeletePeeringConnectionWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call { + return &NetworkPeeringApi_DeletePeeringConnectionWithParams_Call{Call: _e.mock.On("DeletePeeringConnectionWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePeeringConnectionApiParams)) *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePeeringConnectionApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call) Return(_a0 admin.DeletePeeringConnectionApiRequest) *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePeeringConnectionApiParams) admin.DeletePeeringConnectionApiRequest) *NetworkPeeringApi_DeletePeeringConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringContainer provides a mock function with given fields: ctx, groupId, containerId +func (_m *NetworkPeeringApi) DeletePeeringContainer(ctx context.Context, groupId string, containerId string) admin.DeletePeeringContainerApiRequest { + ret := _m.Called(ctx, groupId, containerId) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringContainer") + } + + var r0 admin.DeletePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeletePeeringContainerApiRequest); ok { + r0 = rf(ctx, groupId, containerId) + } else { + r0 = ret.Get(0).(admin.DeletePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DeletePeeringContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringContainer' +type NetworkPeeringApi_DeletePeeringContainer_Call struct { + *mock.Call +} + +// DeletePeeringContainer is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - containerId string +func (_e *NetworkPeeringApi_Expecter) DeletePeeringContainer(ctx interface{}, groupId interface{}, containerId interface{}) *NetworkPeeringApi_DeletePeeringContainer_Call { + return &NetworkPeeringApi_DeletePeeringContainer_Call{Call: _e.mock.On("DeletePeeringContainer", ctx, groupId, containerId)} +} + +func (_c *NetworkPeeringApi_DeletePeeringContainer_Call) Run(run func(ctx context.Context, groupId string, containerId string)) *NetworkPeeringApi_DeletePeeringContainer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainer_Call) Return(_a0 admin.DeletePeeringContainerApiRequest) *NetworkPeeringApi_DeletePeeringContainer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainer_Call) RunAndReturn(run func(context.Context, string, string) admin.DeletePeeringContainerApiRequest) *NetworkPeeringApi_DeletePeeringContainer_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringContainerExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) DeletePeeringContainerExecute(r admin.DeletePeeringContainerApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringContainerExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePeeringContainerApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePeeringContainerApiRequest) 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.DeletePeeringContainerApiRequest) *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.DeletePeeringContainerApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_DeletePeeringContainerExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringContainerExecute' +type NetworkPeeringApi_DeletePeeringContainerExecute_Call struct { + *mock.Call +} + +// DeletePeeringContainerExecute is a helper method to define mock.On call +// - r admin.DeletePeeringContainerApiRequest +func (_e *NetworkPeeringApi_Expecter) DeletePeeringContainerExecute(r interface{}) *NetworkPeeringApi_DeletePeeringContainerExecute_Call { + return &NetworkPeeringApi_DeletePeeringContainerExecute_Call{Call: _e.mock.On("DeletePeeringContainerExecute", r)} +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerExecute_Call) Run(run func(r admin.DeletePeeringContainerApiRequest)) *NetworkPeeringApi_DeletePeeringContainerExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePeeringContainerApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *NetworkPeeringApi_DeletePeeringContainerExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerExecute_Call) RunAndReturn(run func(admin.DeletePeeringContainerApiRequest) (map[string]interface{}, *http.Response, error)) *NetworkPeeringApi_DeletePeeringContainerExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePeeringContainerWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) DeletePeeringContainerWithParams(ctx context.Context, args *admin.DeletePeeringContainerApiParams) admin.DeletePeeringContainerApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePeeringContainerWithParams") + } + + var r0 admin.DeletePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePeeringContainerApiParams) admin.DeletePeeringContainerApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DeletePeeringContainerWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePeeringContainerWithParams' +type NetworkPeeringApi_DeletePeeringContainerWithParams_Call struct { + *mock.Call +} + +// DeletePeeringContainerWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePeeringContainerApiParams +func (_e *NetworkPeeringApi_Expecter) DeletePeeringContainerWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_DeletePeeringContainerWithParams_Call { + return &NetworkPeeringApi_DeletePeeringContainerWithParams_Call{Call: _e.mock.On("DeletePeeringContainerWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePeeringContainerApiParams)) *NetworkPeeringApi_DeletePeeringContainerWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePeeringContainerApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerWithParams_Call) Return(_a0 admin.DeletePeeringContainerApiRequest) *NetworkPeeringApi_DeletePeeringContainerWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DeletePeeringContainerWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePeeringContainerApiParams) admin.DeletePeeringContainerApiRequest) *NetworkPeeringApi_DeletePeeringContainerWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DisablePeering provides a mock function with given fields: ctx, groupId, privateIPMode +func (_m *NetworkPeeringApi) DisablePeering(ctx context.Context, groupId string, privateIPMode *admin.PrivateIPMode) admin.DisablePeeringApiRequest { + ret := _m.Called(ctx, groupId, privateIPMode) + + if len(ret) == 0 { + panic("no return value specified for DisablePeering") + } + + var r0 admin.DisablePeeringApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.PrivateIPMode) admin.DisablePeeringApiRequest); ok { + r0 = rf(ctx, groupId, privateIPMode) + } else { + r0 = ret.Get(0).(admin.DisablePeeringApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DisablePeering_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisablePeering' +type NetworkPeeringApi_DisablePeering_Call struct { + *mock.Call +} + +// DisablePeering is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - privateIPMode *admin.PrivateIPMode +func (_e *NetworkPeeringApi_Expecter) DisablePeering(ctx interface{}, groupId interface{}, privateIPMode interface{}) *NetworkPeeringApi_DisablePeering_Call { + return &NetworkPeeringApi_DisablePeering_Call{Call: _e.mock.On("DisablePeering", ctx, groupId, privateIPMode)} +} + +func (_c *NetworkPeeringApi_DisablePeering_Call) Run(run func(ctx context.Context, groupId string, privateIPMode *admin.PrivateIPMode)) *NetworkPeeringApi_DisablePeering_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.PrivateIPMode)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeering_Call) Return(_a0 admin.DisablePeeringApiRequest) *NetworkPeeringApi_DisablePeering_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeering_Call) RunAndReturn(run func(context.Context, string, *admin.PrivateIPMode) admin.DisablePeeringApiRequest) *NetworkPeeringApi_DisablePeering_Call { + _c.Call.Return(run) + return _c +} + +// DisablePeeringExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) DisablePeeringExecute(r admin.DisablePeeringApiRequest) (*admin.PrivateIPMode, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DisablePeeringExecute") + } + + var r0 *admin.PrivateIPMode + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DisablePeeringApiRequest) (*admin.PrivateIPMode, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DisablePeeringApiRequest) *admin.PrivateIPMode); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PrivateIPMode) + } + } + + if rf, ok := ret.Get(1).(func(admin.DisablePeeringApiRequest) *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.DisablePeeringApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_DisablePeeringExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisablePeeringExecute' +type NetworkPeeringApi_DisablePeeringExecute_Call struct { + *mock.Call +} + +// DisablePeeringExecute is a helper method to define mock.On call +// - r admin.DisablePeeringApiRequest +func (_e *NetworkPeeringApi_Expecter) DisablePeeringExecute(r interface{}) *NetworkPeeringApi_DisablePeeringExecute_Call { + return &NetworkPeeringApi_DisablePeeringExecute_Call{Call: _e.mock.On("DisablePeeringExecute", r)} +} + +func (_c *NetworkPeeringApi_DisablePeeringExecute_Call) Run(run func(r admin.DisablePeeringApiRequest)) *NetworkPeeringApi_DisablePeeringExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DisablePeeringApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeeringExecute_Call) Return(_a0 *admin.PrivateIPMode, _a1 *http.Response, _a2 error) *NetworkPeeringApi_DisablePeeringExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeeringExecute_Call) RunAndReturn(run func(admin.DisablePeeringApiRequest) (*admin.PrivateIPMode, *http.Response, error)) *NetworkPeeringApi_DisablePeeringExecute_Call { + _c.Call.Return(run) + return _c +} + +// DisablePeeringWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) DisablePeeringWithParams(ctx context.Context, args *admin.DisablePeeringApiParams) admin.DisablePeeringApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DisablePeeringWithParams") + } + + var r0 admin.DisablePeeringApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DisablePeeringApiParams) admin.DisablePeeringApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DisablePeeringApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_DisablePeeringWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisablePeeringWithParams' +type NetworkPeeringApi_DisablePeeringWithParams_Call struct { + *mock.Call +} + +// DisablePeeringWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DisablePeeringApiParams +func (_e *NetworkPeeringApi_Expecter) DisablePeeringWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_DisablePeeringWithParams_Call { + return &NetworkPeeringApi_DisablePeeringWithParams_Call{Call: _e.mock.On("DisablePeeringWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_DisablePeeringWithParams_Call) Run(run func(ctx context.Context, args *admin.DisablePeeringApiParams)) *NetworkPeeringApi_DisablePeeringWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DisablePeeringApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeeringWithParams_Call) Return(_a0 admin.DisablePeeringApiRequest) *NetworkPeeringApi_DisablePeeringWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_DisablePeeringWithParams_Call) RunAndReturn(run func(context.Context, *admin.DisablePeeringApiParams) admin.DisablePeeringApiRequest) *NetworkPeeringApi_DisablePeeringWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringConnection provides a mock function with given fields: ctx, groupId, peerId +func (_m *NetworkPeeringApi) GetPeeringConnection(ctx context.Context, groupId string, peerId string) admin.GetPeeringConnectionApiRequest { + ret := _m.Called(ctx, groupId, peerId) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringConnection") + } + + var r0 admin.GetPeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetPeeringConnectionApiRequest); ok { + r0 = rf(ctx, groupId, peerId) + } else { + r0 = ret.Get(0).(admin.GetPeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_GetPeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringConnection' +type NetworkPeeringApi_GetPeeringConnection_Call struct { + *mock.Call +} + +// GetPeeringConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - peerId string +func (_e *NetworkPeeringApi_Expecter) GetPeeringConnection(ctx interface{}, groupId interface{}, peerId interface{}) *NetworkPeeringApi_GetPeeringConnection_Call { + return &NetworkPeeringApi_GetPeeringConnection_Call{Call: _e.mock.On("GetPeeringConnection", ctx, groupId, peerId)} +} + +func (_c *NetworkPeeringApi_GetPeeringConnection_Call) Run(run func(ctx context.Context, groupId string, peerId string)) *NetworkPeeringApi_GetPeeringConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnection_Call) Return(_a0 admin.GetPeeringConnectionApiRequest) *NetworkPeeringApi_GetPeeringConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnection_Call) RunAndReturn(run func(context.Context, string, string) admin.GetPeeringConnectionApiRequest) *NetworkPeeringApi_GetPeeringConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringConnectionExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) GetPeeringConnectionExecute(r admin.GetPeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringConnectionExecute") + } + + var r0 *admin.BaseNetworkPeeringConnectionSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPeeringConnectionApiRequest) *admin.BaseNetworkPeeringConnectionSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BaseNetworkPeeringConnectionSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPeeringConnectionApiRequest) *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.GetPeeringConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_GetPeeringConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringConnectionExecute' +type NetworkPeeringApi_GetPeeringConnectionExecute_Call struct { + *mock.Call +} + +// GetPeeringConnectionExecute is a helper method to define mock.On call +// - r admin.GetPeeringConnectionApiRequest +func (_e *NetworkPeeringApi_Expecter) GetPeeringConnectionExecute(r interface{}) *NetworkPeeringApi_GetPeeringConnectionExecute_Call { + return &NetworkPeeringApi_GetPeeringConnectionExecute_Call{Call: _e.mock.On("GetPeeringConnectionExecute", r)} +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionExecute_Call) Run(run func(r admin.GetPeeringConnectionApiRequest)) *NetworkPeeringApi_GetPeeringConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPeeringConnectionApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionExecute_Call) Return(_a0 *admin.BaseNetworkPeeringConnectionSettings, _a1 *http.Response, _a2 error) *NetworkPeeringApi_GetPeeringConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionExecute_Call) RunAndReturn(run func(admin.GetPeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)) *NetworkPeeringApi_GetPeeringConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) GetPeeringConnectionWithParams(ctx context.Context, args *admin.GetPeeringConnectionApiParams) admin.GetPeeringConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringConnectionWithParams") + } + + var r0 admin.GetPeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPeeringConnectionApiParams) admin.GetPeeringConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_GetPeeringConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringConnectionWithParams' +type NetworkPeeringApi_GetPeeringConnectionWithParams_Call struct { + *mock.Call +} + +// GetPeeringConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPeeringConnectionApiParams +func (_e *NetworkPeeringApi_Expecter) GetPeeringConnectionWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_GetPeeringConnectionWithParams_Call { + return &NetworkPeeringApi_GetPeeringConnectionWithParams_Call{Call: _e.mock.On("GetPeeringConnectionWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPeeringConnectionApiParams)) *NetworkPeeringApi_GetPeeringConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPeeringConnectionApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionWithParams_Call) Return(_a0 admin.GetPeeringConnectionApiRequest) *NetworkPeeringApi_GetPeeringConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPeeringConnectionApiParams) admin.GetPeeringConnectionApiRequest) *NetworkPeeringApi_GetPeeringConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringContainer provides a mock function with given fields: ctx, groupId, containerId +func (_m *NetworkPeeringApi) GetPeeringContainer(ctx context.Context, groupId string, containerId string) admin.GetPeeringContainerApiRequest { + ret := _m.Called(ctx, groupId, containerId) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringContainer") + } + + var r0 admin.GetPeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetPeeringContainerApiRequest); ok { + r0 = rf(ctx, groupId, containerId) + } else { + r0 = ret.Get(0).(admin.GetPeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_GetPeeringContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringContainer' +type NetworkPeeringApi_GetPeeringContainer_Call struct { + *mock.Call +} + +// GetPeeringContainer is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - containerId string +func (_e *NetworkPeeringApi_Expecter) GetPeeringContainer(ctx interface{}, groupId interface{}, containerId interface{}) *NetworkPeeringApi_GetPeeringContainer_Call { + return &NetworkPeeringApi_GetPeeringContainer_Call{Call: _e.mock.On("GetPeeringContainer", ctx, groupId, containerId)} +} + +func (_c *NetworkPeeringApi_GetPeeringContainer_Call) Run(run func(ctx context.Context, groupId string, containerId string)) *NetworkPeeringApi_GetPeeringContainer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainer_Call) Return(_a0 admin.GetPeeringContainerApiRequest) *NetworkPeeringApi_GetPeeringContainer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainer_Call) RunAndReturn(run func(context.Context, string, string) admin.GetPeeringContainerApiRequest) *NetworkPeeringApi_GetPeeringContainer_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringContainerExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) GetPeeringContainerExecute(r admin.GetPeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringContainerExecute") + } + + var r0 *admin.CloudProviderContainer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPeeringContainerApiRequest) *admin.CloudProviderContainer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderContainer) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPeeringContainerApiRequest) *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.GetPeeringContainerApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_GetPeeringContainerExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringContainerExecute' +type NetworkPeeringApi_GetPeeringContainerExecute_Call struct { + *mock.Call +} + +// GetPeeringContainerExecute is a helper method to define mock.On call +// - r admin.GetPeeringContainerApiRequest +func (_e *NetworkPeeringApi_Expecter) GetPeeringContainerExecute(r interface{}) *NetworkPeeringApi_GetPeeringContainerExecute_Call { + return &NetworkPeeringApi_GetPeeringContainerExecute_Call{Call: _e.mock.On("GetPeeringContainerExecute", r)} +} + +func (_c *NetworkPeeringApi_GetPeeringContainerExecute_Call) Run(run func(r admin.GetPeeringContainerApiRequest)) *NetworkPeeringApi_GetPeeringContainerExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPeeringContainerApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainerExecute_Call) Return(_a0 *admin.CloudProviderContainer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_GetPeeringContainerExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainerExecute_Call) RunAndReturn(run func(admin.GetPeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)) *NetworkPeeringApi_GetPeeringContainerExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPeeringContainerWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) GetPeeringContainerWithParams(ctx context.Context, args *admin.GetPeeringContainerApiParams) admin.GetPeeringContainerApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPeeringContainerWithParams") + } + + var r0 admin.GetPeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPeeringContainerApiParams) admin.GetPeeringContainerApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_GetPeeringContainerWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPeeringContainerWithParams' +type NetworkPeeringApi_GetPeeringContainerWithParams_Call struct { + *mock.Call +} + +// GetPeeringContainerWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPeeringContainerApiParams +func (_e *NetworkPeeringApi_Expecter) GetPeeringContainerWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_GetPeeringContainerWithParams_Call { + return &NetworkPeeringApi_GetPeeringContainerWithParams_Call{Call: _e.mock.On("GetPeeringContainerWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_GetPeeringContainerWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPeeringContainerApiParams)) *NetworkPeeringApi_GetPeeringContainerWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPeeringContainerApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainerWithParams_Call) Return(_a0 admin.GetPeeringContainerApiRequest) *NetworkPeeringApi_GetPeeringContainerWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_GetPeeringContainerWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPeeringContainerApiParams) admin.GetPeeringContainerApiRequest) *NetworkPeeringApi_GetPeeringContainerWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringConnections provides a mock function with given fields: ctx, groupId +func (_m *NetworkPeeringApi) ListPeeringConnections(ctx context.Context, groupId string) admin.ListPeeringConnectionsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringConnections") + } + + var r0 admin.ListPeeringConnectionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListPeeringConnectionsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListPeeringConnectionsApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringConnections' +type NetworkPeeringApi_ListPeeringConnections_Call struct { + *mock.Call +} + +// ListPeeringConnections is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *NetworkPeeringApi_Expecter) ListPeeringConnections(ctx interface{}, groupId interface{}) *NetworkPeeringApi_ListPeeringConnections_Call { + return &NetworkPeeringApi_ListPeeringConnections_Call{Call: _e.mock.On("ListPeeringConnections", ctx, groupId)} +} + +func (_c *NetworkPeeringApi_ListPeeringConnections_Call) Run(run func(ctx context.Context, groupId string)) *NetworkPeeringApi_ListPeeringConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnections_Call) Return(_a0 admin.ListPeeringConnectionsApiRequest) *NetworkPeeringApi_ListPeeringConnections_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnections_Call) RunAndReturn(run func(context.Context, string) admin.ListPeeringConnectionsApiRequest) *NetworkPeeringApi_ListPeeringConnections_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringConnectionsExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) ListPeeringConnectionsExecute(r admin.ListPeeringConnectionsApiRequest) (*admin.PaginatedContainerPeer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringConnectionsExecute") + } + + var r0 *admin.PaginatedContainerPeer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPeeringConnectionsApiRequest) (*admin.PaginatedContainerPeer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPeeringConnectionsApiRequest) *admin.PaginatedContainerPeer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedContainerPeer) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPeeringConnectionsApiRequest) *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.ListPeeringConnectionsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_ListPeeringConnectionsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringConnectionsExecute' +type NetworkPeeringApi_ListPeeringConnectionsExecute_Call struct { + *mock.Call +} + +// ListPeeringConnectionsExecute is a helper method to define mock.On call +// - r admin.ListPeeringConnectionsApiRequest +func (_e *NetworkPeeringApi_Expecter) ListPeeringConnectionsExecute(r interface{}) *NetworkPeeringApi_ListPeeringConnectionsExecute_Call { + return &NetworkPeeringApi_ListPeeringConnectionsExecute_Call{Call: _e.mock.On("ListPeeringConnectionsExecute", r)} +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsExecute_Call) Run(run func(r admin.ListPeeringConnectionsApiRequest)) *NetworkPeeringApi_ListPeeringConnectionsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPeeringConnectionsApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsExecute_Call) Return(_a0 *admin.PaginatedContainerPeer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_ListPeeringConnectionsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsExecute_Call) RunAndReturn(run func(admin.ListPeeringConnectionsApiRequest) (*admin.PaginatedContainerPeer, *http.Response, error)) *NetworkPeeringApi_ListPeeringConnectionsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringConnectionsWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) ListPeeringConnectionsWithParams(ctx context.Context, args *admin.ListPeeringConnectionsApiParams) admin.ListPeeringConnectionsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringConnectionsWithParams") + } + + var r0 admin.ListPeeringConnectionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPeeringConnectionsApiParams) admin.ListPeeringConnectionsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPeeringConnectionsApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringConnectionsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringConnectionsWithParams' +type NetworkPeeringApi_ListPeeringConnectionsWithParams_Call struct { + *mock.Call +} + +// ListPeeringConnectionsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPeeringConnectionsApiParams +func (_e *NetworkPeeringApi_Expecter) ListPeeringConnectionsWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call { + return &NetworkPeeringApi_ListPeeringConnectionsWithParams_Call{Call: _e.mock.On("ListPeeringConnectionsWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPeeringConnectionsApiParams)) *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPeeringConnectionsApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call) Return(_a0 admin.ListPeeringConnectionsApiRequest) *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPeeringConnectionsApiParams) admin.ListPeeringConnectionsApiRequest) *NetworkPeeringApi_ListPeeringConnectionsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainerByCloudProvider provides a mock function with given fields: ctx, groupId +func (_m *NetworkPeeringApi) ListPeeringContainerByCloudProvider(ctx context.Context, groupId string) admin.ListPeeringContainerByCloudProviderApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainerByCloudProvider") + } + + var r0 admin.ListPeeringContainerByCloudProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListPeeringContainerByCloudProviderApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListPeeringContainerByCloudProviderApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainerByCloudProvider' +type NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call struct { + *mock.Call +} + +// ListPeeringContainerByCloudProvider is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainerByCloudProvider(ctx interface{}, groupId interface{}) *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call { + return &NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call{Call: _e.mock.On("ListPeeringContainerByCloudProvider", ctx, groupId)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call) Run(run func(ctx context.Context, groupId string)) *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call) Return(_a0 admin.ListPeeringContainerByCloudProviderApiRequest) *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call) RunAndReturn(run func(context.Context, string) admin.ListPeeringContainerByCloudProviderApiRequest) *NetworkPeeringApi_ListPeeringContainerByCloudProvider_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainerByCloudProviderExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) ListPeeringContainerByCloudProviderExecute(r admin.ListPeeringContainerByCloudProviderApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainerByCloudProviderExecute") + } + + var r0 *admin.PaginatedCloudProviderContainer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPeeringContainerByCloudProviderApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPeeringContainerByCloudProviderApiRequest) *admin.PaginatedCloudProviderContainer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedCloudProviderContainer) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPeeringContainerByCloudProviderApiRequest) *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.ListPeeringContainerByCloudProviderApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainerByCloudProviderExecute' +type NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call struct { + *mock.Call +} + +// ListPeeringContainerByCloudProviderExecute is a helper method to define mock.On call +// - r admin.ListPeeringContainerByCloudProviderApiRequest +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainerByCloudProviderExecute(r interface{}) *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call { + return &NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call{Call: _e.mock.On("ListPeeringContainerByCloudProviderExecute", r)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call) Run(run func(r admin.ListPeeringContainerByCloudProviderApiRequest)) *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPeeringContainerByCloudProviderApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call) Return(_a0 *admin.PaginatedCloudProviderContainer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call) RunAndReturn(run func(admin.ListPeeringContainerByCloudProviderApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error)) *NetworkPeeringApi_ListPeeringContainerByCloudProviderExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainerByCloudProviderWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) ListPeeringContainerByCloudProviderWithParams(ctx context.Context, args *admin.ListPeeringContainerByCloudProviderApiParams) admin.ListPeeringContainerByCloudProviderApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainerByCloudProviderWithParams") + } + + var r0 admin.ListPeeringContainerByCloudProviderApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPeeringContainerByCloudProviderApiParams) admin.ListPeeringContainerByCloudProviderApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPeeringContainerByCloudProviderApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainerByCloudProviderWithParams' +type NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call struct { + *mock.Call +} + +// ListPeeringContainerByCloudProviderWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPeeringContainerByCloudProviderApiParams +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainerByCloudProviderWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call { + return &NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call{Call: _e.mock.On("ListPeeringContainerByCloudProviderWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPeeringContainerByCloudProviderApiParams)) *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPeeringContainerByCloudProviderApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call) Return(_a0 admin.ListPeeringContainerByCloudProviderApiRequest) *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPeeringContainerByCloudProviderApiParams) admin.ListPeeringContainerByCloudProviderApiRequest) *NetworkPeeringApi_ListPeeringContainerByCloudProviderWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainers provides a mock function with given fields: ctx, groupId +func (_m *NetworkPeeringApi) ListPeeringContainers(ctx context.Context, groupId string) admin.ListPeeringContainersApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainers") + } + + var r0 admin.ListPeeringContainersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListPeeringContainersApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListPeeringContainersApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainers' +type NetworkPeeringApi_ListPeeringContainers_Call struct { + *mock.Call +} + +// ListPeeringContainers is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainers(ctx interface{}, groupId interface{}) *NetworkPeeringApi_ListPeeringContainers_Call { + return &NetworkPeeringApi_ListPeeringContainers_Call{Call: _e.mock.On("ListPeeringContainers", ctx, groupId)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainers_Call) Run(run func(ctx context.Context, groupId string)) *NetworkPeeringApi_ListPeeringContainers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainers_Call) Return(_a0 admin.ListPeeringContainersApiRequest) *NetworkPeeringApi_ListPeeringContainers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainers_Call) RunAndReturn(run func(context.Context, string) admin.ListPeeringContainersApiRequest) *NetworkPeeringApi_ListPeeringContainers_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainersExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) ListPeeringContainersExecute(r admin.ListPeeringContainersApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainersExecute") + } + + var r0 *admin.PaginatedCloudProviderContainer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPeeringContainersApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPeeringContainersApiRequest) *admin.PaginatedCloudProviderContainer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedCloudProviderContainer) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPeeringContainersApiRequest) *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.ListPeeringContainersApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_ListPeeringContainersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainersExecute' +type NetworkPeeringApi_ListPeeringContainersExecute_Call struct { + *mock.Call +} + +// ListPeeringContainersExecute is a helper method to define mock.On call +// - r admin.ListPeeringContainersApiRequest +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainersExecute(r interface{}) *NetworkPeeringApi_ListPeeringContainersExecute_Call { + return &NetworkPeeringApi_ListPeeringContainersExecute_Call{Call: _e.mock.On("ListPeeringContainersExecute", r)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainersExecute_Call) Run(run func(r admin.ListPeeringContainersApiRequest)) *NetworkPeeringApi_ListPeeringContainersExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPeeringContainersApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainersExecute_Call) Return(_a0 *admin.PaginatedCloudProviderContainer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_ListPeeringContainersExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainersExecute_Call) RunAndReturn(run func(admin.ListPeeringContainersApiRequest) (*admin.PaginatedCloudProviderContainer, *http.Response, error)) *NetworkPeeringApi_ListPeeringContainersExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPeeringContainersWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) ListPeeringContainersWithParams(ctx context.Context, args *admin.ListPeeringContainersApiParams) admin.ListPeeringContainersApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPeeringContainersWithParams") + } + + var r0 admin.ListPeeringContainersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPeeringContainersApiParams) admin.ListPeeringContainersApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPeeringContainersApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_ListPeeringContainersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeeringContainersWithParams' +type NetworkPeeringApi_ListPeeringContainersWithParams_Call struct { + *mock.Call +} + +// ListPeeringContainersWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPeeringContainersApiParams +func (_e *NetworkPeeringApi_Expecter) ListPeeringContainersWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_ListPeeringContainersWithParams_Call { + return &NetworkPeeringApi_ListPeeringContainersWithParams_Call{Call: _e.mock.On("ListPeeringContainersWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_ListPeeringContainersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPeeringContainersApiParams)) *NetworkPeeringApi_ListPeeringContainersWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPeeringContainersApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainersWithParams_Call) Return(_a0 admin.ListPeeringContainersApiRequest) *NetworkPeeringApi_ListPeeringContainersWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_ListPeeringContainersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPeeringContainersApiParams) admin.ListPeeringContainersApiRequest) *NetworkPeeringApi_ListPeeringContainersWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringConnection provides a mock function with given fields: ctx, groupId, peerId, baseNetworkPeeringConnectionSettings +func (_m *NetworkPeeringApi) UpdatePeeringConnection(ctx context.Context, groupId string, peerId string, baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings) admin.UpdatePeeringConnectionApiRequest { + ret := _m.Called(ctx, groupId, peerId, baseNetworkPeeringConnectionSettings) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringConnection") + } + + var r0 admin.UpdatePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.BaseNetworkPeeringConnectionSettings) admin.UpdatePeeringConnectionApiRequest); ok { + r0 = rf(ctx, groupId, peerId, baseNetworkPeeringConnectionSettings) + } else { + r0 = ret.Get(0).(admin.UpdatePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_UpdatePeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringConnection' +type NetworkPeeringApi_UpdatePeeringConnection_Call struct { + *mock.Call +} + +// UpdatePeeringConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - peerId string +// - baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringConnection(ctx interface{}, groupId interface{}, peerId interface{}, baseNetworkPeeringConnectionSettings interface{}) *NetworkPeeringApi_UpdatePeeringConnection_Call { + return &NetworkPeeringApi_UpdatePeeringConnection_Call{Call: _e.mock.On("UpdatePeeringConnection", ctx, groupId, peerId, baseNetworkPeeringConnectionSettings)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnection_Call) Run(run func(ctx context.Context, groupId string, peerId string, baseNetworkPeeringConnectionSettings *admin.BaseNetworkPeeringConnectionSettings)) *NetworkPeeringApi_UpdatePeeringConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.BaseNetworkPeeringConnectionSettings)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnection_Call) Return(_a0 admin.UpdatePeeringConnectionApiRequest) *NetworkPeeringApi_UpdatePeeringConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnection_Call) RunAndReturn(run func(context.Context, string, string, *admin.BaseNetworkPeeringConnectionSettings) admin.UpdatePeeringConnectionApiRequest) *NetworkPeeringApi_UpdatePeeringConnection_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringConnectionExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) UpdatePeeringConnectionExecute(r admin.UpdatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringConnectionExecute") + } + + var r0 *admin.BaseNetworkPeeringConnectionSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdatePeeringConnectionApiRequest) *admin.BaseNetworkPeeringConnectionSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BaseNetworkPeeringConnectionSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdatePeeringConnectionApiRequest) *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.UpdatePeeringConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_UpdatePeeringConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringConnectionExecute' +type NetworkPeeringApi_UpdatePeeringConnectionExecute_Call struct { + *mock.Call +} + +// UpdatePeeringConnectionExecute is a helper method to define mock.On call +// - r admin.UpdatePeeringConnectionApiRequest +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringConnectionExecute(r interface{}) *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call { + return &NetworkPeeringApi_UpdatePeeringConnectionExecute_Call{Call: _e.mock.On("UpdatePeeringConnectionExecute", r)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call) Run(run func(r admin.UpdatePeeringConnectionApiRequest)) *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdatePeeringConnectionApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call) Return(_a0 *admin.BaseNetworkPeeringConnectionSettings, _a1 *http.Response, _a2 error) *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call) RunAndReturn(run func(admin.UpdatePeeringConnectionApiRequest) (*admin.BaseNetworkPeeringConnectionSettings, *http.Response, error)) *NetworkPeeringApi_UpdatePeeringConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) UpdatePeeringConnectionWithParams(ctx context.Context, args *admin.UpdatePeeringConnectionApiParams) admin.UpdatePeeringConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringConnectionWithParams") + } + + var r0 admin.UpdatePeeringConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdatePeeringConnectionApiParams) admin.UpdatePeeringConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdatePeeringConnectionApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringConnectionWithParams' +type NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call struct { + *mock.Call +} + +// UpdatePeeringConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdatePeeringConnectionApiParams +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringConnectionWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call { + return &NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call{Call: _e.mock.On("UpdatePeeringConnectionWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdatePeeringConnectionApiParams)) *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdatePeeringConnectionApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call) Return(_a0 admin.UpdatePeeringConnectionApiRequest) *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdatePeeringConnectionApiParams) admin.UpdatePeeringConnectionApiRequest) *NetworkPeeringApi_UpdatePeeringConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringContainer provides a mock function with given fields: ctx, groupId, containerId, cloudProviderContainer +func (_m *NetworkPeeringApi) UpdatePeeringContainer(ctx context.Context, groupId string, containerId string, cloudProviderContainer *admin.CloudProviderContainer) admin.UpdatePeeringContainerApiRequest { + ret := _m.Called(ctx, groupId, containerId, cloudProviderContainer) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringContainer") + } + + var r0 admin.UpdatePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.CloudProviderContainer) admin.UpdatePeeringContainerApiRequest); ok { + r0 = rf(ctx, groupId, containerId, cloudProviderContainer) + } else { + r0 = ret.Get(0).(admin.UpdatePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_UpdatePeeringContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringContainer' +type NetworkPeeringApi_UpdatePeeringContainer_Call struct { + *mock.Call +} + +// UpdatePeeringContainer is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - containerId string +// - cloudProviderContainer *admin.CloudProviderContainer +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringContainer(ctx interface{}, groupId interface{}, containerId interface{}, cloudProviderContainer interface{}) *NetworkPeeringApi_UpdatePeeringContainer_Call { + return &NetworkPeeringApi_UpdatePeeringContainer_Call{Call: _e.mock.On("UpdatePeeringContainer", ctx, groupId, containerId, cloudProviderContainer)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainer_Call) Run(run func(ctx context.Context, groupId string, containerId string, cloudProviderContainer *admin.CloudProviderContainer)) *NetworkPeeringApi_UpdatePeeringContainer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.CloudProviderContainer)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainer_Call) Return(_a0 admin.UpdatePeeringContainerApiRequest) *NetworkPeeringApi_UpdatePeeringContainer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainer_Call) RunAndReturn(run func(context.Context, string, string, *admin.CloudProviderContainer) admin.UpdatePeeringContainerApiRequest) *NetworkPeeringApi_UpdatePeeringContainer_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringContainerExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) UpdatePeeringContainerExecute(r admin.UpdatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringContainerExecute") + } + + var r0 *admin.CloudProviderContainer + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdatePeeringContainerApiRequest) *admin.CloudProviderContainer); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CloudProviderContainer) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdatePeeringContainerApiRequest) *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.UpdatePeeringContainerApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_UpdatePeeringContainerExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringContainerExecute' +type NetworkPeeringApi_UpdatePeeringContainerExecute_Call struct { + *mock.Call +} + +// UpdatePeeringContainerExecute is a helper method to define mock.On call +// - r admin.UpdatePeeringContainerApiRequest +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringContainerExecute(r interface{}) *NetworkPeeringApi_UpdatePeeringContainerExecute_Call { + return &NetworkPeeringApi_UpdatePeeringContainerExecute_Call{Call: _e.mock.On("UpdatePeeringContainerExecute", r)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerExecute_Call) Run(run func(r admin.UpdatePeeringContainerApiRequest)) *NetworkPeeringApi_UpdatePeeringContainerExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdatePeeringContainerApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerExecute_Call) Return(_a0 *admin.CloudProviderContainer, _a1 *http.Response, _a2 error) *NetworkPeeringApi_UpdatePeeringContainerExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerExecute_Call) RunAndReturn(run func(admin.UpdatePeeringContainerApiRequest) (*admin.CloudProviderContainer, *http.Response, error)) *NetworkPeeringApi_UpdatePeeringContainerExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePeeringContainerWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) UpdatePeeringContainerWithParams(ctx context.Context, args *admin.UpdatePeeringContainerApiParams) admin.UpdatePeeringContainerApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdatePeeringContainerWithParams") + } + + var r0 admin.UpdatePeeringContainerApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdatePeeringContainerApiParams) admin.UpdatePeeringContainerApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdatePeeringContainerApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_UpdatePeeringContainerWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePeeringContainerWithParams' +type NetworkPeeringApi_UpdatePeeringContainerWithParams_Call struct { + *mock.Call +} + +// UpdatePeeringContainerWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdatePeeringContainerApiParams +func (_e *NetworkPeeringApi_Expecter) UpdatePeeringContainerWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call { + return &NetworkPeeringApi_UpdatePeeringContainerWithParams_Call{Call: _e.mock.On("UpdatePeeringContainerWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdatePeeringContainerApiParams)) *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdatePeeringContainerApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call) Return(_a0 admin.UpdatePeeringContainerApiRequest) *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdatePeeringContainerApiParams) admin.UpdatePeeringContainerApiRequest) *NetworkPeeringApi_UpdatePeeringContainerWithParams_Call { + _c.Call.Return(run) + return _c +} + +// VerifyConnectViaPeeringOnlyModeForOneProject provides a mock function with given fields: ctx, groupId +func (_m *NetworkPeeringApi) VerifyConnectViaPeeringOnlyModeForOneProject(ctx context.Context, groupId string) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for VerifyConnectViaPeeringOnlyModeForOneProject") + } + + var r0 admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyConnectViaPeeringOnlyModeForOneProject' +type NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call struct { + *mock.Call +} + +// VerifyConnectViaPeeringOnlyModeForOneProject is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *NetworkPeeringApi_Expecter) VerifyConnectViaPeeringOnlyModeForOneProject(ctx interface{}, groupId interface{}) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call { + return &NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call{Call: _e.mock.On("VerifyConnectViaPeeringOnlyModeForOneProject", ctx, groupId)} +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call) Run(run func(ctx context.Context, groupId string)) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call) Return(_a0 admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call) RunAndReturn(run func(context.Context, string) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProject_Call { + _c.Call.Return(run) + return _c +} + +// VerifyConnectViaPeeringOnlyModeForOneProjectExecute provides a mock function with given fields: r +func (_m *NetworkPeeringApi) VerifyConnectViaPeeringOnlyModeForOneProjectExecute(r admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) (*admin.PrivateIPMode, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for VerifyConnectViaPeeringOnlyModeForOneProjectExecute") + } + + var r0 *admin.PrivateIPMode + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) (*admin.PrivateIPMode, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *admin.PrivateIPMode); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PrivateIPMode) + } + } + + if rf, ok := ret.Get(1).(func(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *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.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyConnectViaPeeringOnlyModeForOneProjectExecute' +type NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call struct { + *mock.Call +} + +// VerifyConnectViaPeeringOnlyModeForOneProjectExecute is a helper method to define mock.On call +// - r admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest +func (_e *NetworkPeeringApi_Expecter) VerifyConnectViaPeeringOnlyModeForOneProjectExecute(r interface{}) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call { + return &NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call{Call: _e.mock.On("VerifyConnectViaPeeringOnlyModeForOneProjectExecute", r)} +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call) Run(run func(r admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest)) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest)) + }) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call) Return(_a0 *admin.PrivateIPMode, _a1 *http.Response, _a2 error) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call) RunAndReturn(run func(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) (*admin.PrivateIPMode, *http.Response, error)) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectExecute_Call { + _c.Call.Return(run) + return _c +} + +// VerifyConnectViaPeeringOnlyModeForOneProjectWithParams provides a mock function with given fields: ctx, args +func (_m *NetworkPeeringApi) VerifyConnectViaPeeringOnlyModeForOneProjectWithParams(ctx context.Context, args *admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for VerifyConnectViaPeeringOnlyModeForOneProjectWithParams") + } + + var r0 admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) + } + + return r0 +} + +// NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyConnectViaPeeringOnlyModeForOneProjectWithParams' +type NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call struct { + *mock.Call +} + +// VerifyConnectViaPeeringOnlyModeForOneProjectWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams +func (_e *NetworkPeeringApi_Expecter) VerifyConnectViaPeeringOnlyModeForOneProjectWithParams(ctx interface{}, args interface{}) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call { + return &NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call{Call: _e.mock.On("VerifyConnectViaPeeringOnlyModeForOneProjectWithParams", ctx, args)} +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams)) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams)) + }) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call) Return(_a0 admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiParams) admin.VerifyConnectViaPeeringOnlyModeForOneProjectApiRequest) *NetworkPeeringApi_VerifyConnectViaPeeringOnlyModeForOneProjectWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewNetworkPeeringApi creates a new instance of NetworkPeeringApi. 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 NewNetworkPeeringApi(t interface { + mock.TestingT + Cleanup(func()) +}) *NetworkPeeringApi { + mock := &NetworkPeeringApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/online_archive_api.go b/mockadmin/online_archive_api.go new file mode 100644 index 000000000..b482cc7c6 --- /dev/null +++ b/mockadmin/online_archive_api.go @@ -0,0 +1,1019 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + io "io" + + mock "github.com/stretchr/testify/mock" +) + +// OnlineArchiveApi is an autogenerated mock type for the OnlineArchiveApi type +type OnlineArchiveApi struct { + mock.Mock +} + +type OnlineArchiveApi_Expecter struct { + mock *mock.Mock +} + +func (_m *OnlineArchiveApi) EXPECT() *OnlineArchiveApi_Expecter { + return &OnlineArchiveApi_Expecter{mock: &_m.Mock} +} + +// CreateOnlineArchive provides a mock function with given fields: ctx, groupId, clusterName, backupOnlineArchiveCreate +func (_m *OnlineArchiveApi) CreateOnlineArchive(ctx context.Context, groupId string, clusterName string, backupOnlineArchiveCreate *admin.BackupOnlineArchiveCreate) admin.CreateOnlineArchiveApiRequest { + ret := _m.Called(ctx, groupId, clusterName, backupOnlineArchiveCreate) + + if len(ret) == 0 { + panic("no return value specified for CreateOnlineArchive") + } + + var r0 admin.CreateOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.BackupOnlineArchiveCreate) admin.CreateOnlineArchiveApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, backupOnlineArchiveCreate) + } else { + r0 = ret.Get(0).(admin.CreateOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_CreateOnlineArchive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOnlineArchive' +type OnlineArchiveApi_CreateOnlineArchive_Call struct { + *mock.Call +} + +// CreateOnlineArchive is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - backupOnlineArchiveCreate *admin.BackupOnlineArchiveCreate +func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchive(ctx interface{}, groupId interface{}, clusterName interface{}, backupOnlineArchiveCreate interface{}) *OnlineArchiveApi_CreateOnlineArchive_Call { + return &OnlineArchiveApi_CreateOnlineArchive_Call{Call: _e.mock.On("CreateOnlineArchive", ctx, groupId, clusterName, backupOnlineArchiveCreate)} +} + +func (_c *OnlineArchiveApi_CreateOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, clusterName string, backupOnlineArchiveCreate *admin.BackupOnlineArchiveCreate)) *OnlineArchiveApi_CreateOnlineArchive_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.BackupOnlineArchiveCreate)) + }) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchive_Call) Return(_a0 admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, *admin.BackupOnlineArchiveCreate) admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchive_Call { + _c.Call.Return(run) + return _c +} + +// CreateOnlineArchiveExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) CreateOnlineArchiveExecute(r admin.CreateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateOnlineArchiveExecute") + } + + var r0 *admin.BackupOnlineArchive + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateOnlineArchiveApiRequest) *admin.BackupOnlineArchive); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupOnlineArchive) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateOnlineArchiveApiRequest) *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.CreateOnlineArchiveApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_CreateOnlineArchiveExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOnlineArchiveExecute' +type OnlineArchiveApi_CreateOnlineArchiveExecute_Call struct { + *mock.Call +} + +// CreateOnlineArchiveExecute is a helper method to define mock.On call +// - r admin.CreateOnlineArchiveApiRequest +func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call { + return &OnlineArchiveApi_CreateOnlineArchiveExecute_Call{Call: _e.mock.On("CreateOnlineArchiveExecute", r)} +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveExecute_Call) Run(run func(r admin.CreateOnlineArchiveApiRequest)) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateOnlineArchiveApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveExecute_Call) Return(_a0 *admin.BackupOnlineArchive, _a1 *http.Response, _a2 error) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveExecute_Call) RunAndReturn(run func(admin.CreateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateOnlineArchiveWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) CreateOnlineArchiveWithParams(ctx context.Context, args *admin.CreateOnlineArchiveApiParams) admin.CreateOnlineArchiveApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateOnlineArchiveWithParams") + } + + var r0 admin.CreateOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOnlineArchiveApiParams) admin.CreateOnlineArchiveApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_CreateOnlineArchiveWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOnlineArchiveWithParams' +type OnlineArchiveApi_CreateOnlineArchiveWithParams_Call struct { + *mock.Call +} + +// CreateOnlineArchiveWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateOnlineArchiveApiParams +func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call { + return &OnlineArchiveApi_CreateOnlineArchiveWithParams_Call{Call: _e.mock.On("CreateOnlineArchiveWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateOnlineArchiveApiParams)) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateOnlineArchiveApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call) Return(_a0 admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOnlineArchiveApiParams) admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName +func (_m *OnlineArchiveApi) DeleteOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string) admin.DeleteOnlineArchiveApiRequest { + ret := _m.Called(ctx, groupId, archiveId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for DeleteOnlineArchive") + } + + var r0 admin.DeleteOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteOnlineArchiveApiRequest); ok { + r0 = rf(ctx, groupId, archiveId, clusterName) + } else { + r0 = ret.Get(0).(admin.DeleteOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_DeleteOnlineArchive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOnlineArchive' +type OnlineArchiveApi_DeleteOnlineArchive_Call struct { + *mock.Call +} + +// DeleteOnlineArchive is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - archiveId string +// - clusterName string +func (_e *OnlineArchiveApi_Expecter) DeleteOnlineArchive(ctx interface{}, groupId interface{}, archiveId interface{}, clusterName interface{}) *OnlineArchiveApi_DeleteOnlineArchive_Call { + return &OnlineArchiveApi_DeleteOnlineArchive_Call{Call: _e.mock.On("DeleteOnlineArchive", ctx, groupId, archiveId, clusterName)} +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string)) *OnlineArchiveApi_DeleteOnlineArchive_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 *OnlineArchiveApi_DeleteOnlineArchive_Call) Return(_a0 admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchive_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOnlineArchiveExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) DeleteOnlineArchiveExecute(r admin.DeleteOnlineArchiveApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteOnlineArchiveExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteOnlineArchiveApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteOnlineArchiveApiRequest) 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.DeleteOnlineArchiveApiRequest) *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.DeleteOnlineArchiveApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_DeleteOnlineArchiveExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOnlineArchiveExecute' +type OnlineArchiveApi_DeleteOnlineArchiveExecute_Call struct { + *mock.Call +} + +// DeleteOnlineArchiveExecute is a helper method to define mock.On call +// - r admin.DeleteOnlineArchiveApiRequest +func (_e *OnlineArchiveApi_Expecter) DeleteOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call { + return &OnlineArchiveApi_DeleteOnlineArchiveExecute_Call{Call: _e.mock.On("DeleteOnlineArchiveExecute", r)} +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call) Run(run func(r admin.DeleteOnlineArchiveApiRequest)) *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteOnlineArchiveApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call) RunAndReturn(run func(admin.DeleteOnlineArchiveApiRequest) (map[string]interface{}, *http.Response, error)) *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOnlineArchiveWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) DeleteOnlineArchiveWithParams(ctx context.Context, args *admin.DeleteOnlineArchiveApiParams) admin.DeleteOnlineArchiveApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteOnlineArchiveWithParams") + } + + var r0 admin.DeleteOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteOnlineArchiveApiParams) admin.DeleteOnlineArchiveApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOnlineArchiveWithParams' +type OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call struct { + *mock.Call +} + +// DeleteOnlineArchiveWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteOnlineArchiveApiParams +func (_e *OnlineArchiveApi_Expecter) DeleteOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call { + return &OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call{Call: _e.mock.On("DeleteOnlineArchiveWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteOnlineArchiveApiParams)) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteOnlineArchiveApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call) Return(_a0 admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOnlineArchiveApiParams) admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DownloadOnlineArchiveQueryLogs provides a mock function with given fields: ctx, groupId, clusterName +func (_m *OnlineArchiveApi) DownloadOnlineArchiveQueryLogs(ctx context.Context, groupId string, clusterName string) admin.DownloadOnlineArchiveQueryLogsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for DownloadOnlineArchiveQueryLogs") + } + + var r0 admin.DownloadOnlineArchiveQueryLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DownloadOnlineArchiveQueryLogsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.DownloadOnlineArchiveQueryLogsApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadOnlineArchiveQueryLogs' +type OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call struct { + *mock.Call +} + +// DownloadOnlineArchiveQueryLogs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *OnlineArchiveApi_Expecter) DownloadOnlineArchiveQueryLogs(ctx interface{}, groupId interface{}, clusterName interface{}) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call { + return &OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call{Call: _e.mock.On("DownloadOnlineArchiveQueryLogs", ctx, groupId, clusterName)} +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call) Return(_a0 admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call) RunAndReturn(run func(context.Context, string, string) admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call { + _c.Call.Return(run) + return _c +} + +// DownloadOnlineArchiveQueryLogsExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) DownloadOnlineArchiveQueryLogsExecute(r admin.DownloadOnlineArchiveQueryLogsApiRequest) (io.ReadCloser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DownloadOnlineArchiveQueryLogsExecute") + } + + var r0 io.ReadCloser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DownloadOnlineArchiveQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DownloadOnlineArchiveQueryLogsApiRequest) io.ReadCloser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(admin.DownloadOnlineArchiveQueryLogsApiRequest) *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.DownloadOnlineArchiveQueryLogsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadOnlineArchiveQueryLogsExecute' +type OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call struct { + *mock.Call +} + +// DownloadOnlineArchiveQueryLogsExecute is a helper method to define mock.On call +// - r admin.DownloadOnlineArchiveQueryLogsApiRequest +func (_e *OnlineArchiveApi_Expecter) DownloadOnlineArchiveQueryLogsExecute(r interface{}) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call { + return &OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call{Call: _e.mock.On("DownloadOnlineArchiveQueryLogsExecute", r)} +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call) Run(run func(r admin.DownloadOnlineArchiveQueryLogsApiRequest)) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DownloadOnlineArchiveQueryLogsApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call) RunAndReturn(run func(admin.DownloadOnlineArchiveQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call { + _c.Call.Return(run) + return _c +} + +// DownloadOnlineArchiveQueryLogsWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) DownloadOnlineArchiveQueryLogsWithParams(ctx context.Context, args *admin.DownloadOnlineArchiveQueryLogsApiParams) admin.DownloadOnlineArchiveQueryLogsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DownloadOnlineArchiveQueryLogsWithParams") + } + + var r0 admin.DownloadOnlineArchiveQueryLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadOnlineArchiveQueryLogsApiParams) admin.DownloadOnlineArchiveQueryLogsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DownloadOnlineArchiveQueryLogsApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadOnlineArchiveQueryLogsWithParams' +type OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call struct { + *mock.Call +} + +// DownloadOnlineArchiveQueryLogsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DownloadOnlineArchiveQueryLogsApiParams +func (_e *OnlineArchiveApi_Expecter) DownloadOnlineArchiveQueryLogsWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call { + return &OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call{Call: _e.mock.On("DownloadOnlineArchiveQueryLogsWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadOnlineArchiveQueryLogsApiParams)) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DownloadOnlineArchiveQueryLogsApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call) Return(_a0 admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadOnlineArchiveQueryLogsApiParams) admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName +func (_m *OnlineArchiveApi) GetOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string) admin.GetOnlineArchiveApiRequest { + ret := _m.Called(ctx, groupId, archiveId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetOnlineArchive") + } + + var r0 admin.GetOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetOnlineArchiveApiRequest); ok { + r0 = rf(ctx, groupId, archiveId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_GetOnlineArchive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnlineArchive' +type OnlineArchiveApi_GetOnlineArchive_Call struct { + *mock.Call +} + +// GetOnlineArchive is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - archiveId string +// - clusterName string +func (_e *OnlineArchiveApi_Expecter) GetOnlineArchive(ctx interface{}, groupId interface{}, archiveId interface{}, clusterName interface{}) *OnlineArchiveApi_GetOnlineArchive_Call { + return &OnlineArchiveApi_GetOnlineArchive_Call{Call: _e.mock.On("GetOnlineArchive", ctx, groupId, archiveId, clusterName)} +} + +func (_c *OnlineArchiveApi_GetOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string)) *OnlineArchiveApi_GetOnlineArchive_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 *OnlineArchiveApi_GetOnlineArchive_Call) Return(_a0 admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_GetOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchive_Call { + _c.Call.Return(run) + return _c +} + +// GetOnlineArchiveExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) GetOnlineArchiveExecute(r admin.GetOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOnlineArchiveExecute") + } + + var r0 *admin.BackupOnlineArchive + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOnlineArchiveApiRequest) *admin.BackupOnlineArchive); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupOnlineArchive) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetOnlineArchiveApiRequest) *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.GetOnlineArchiveApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_GetOnlineArchiveExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnlineArchiveExecute' +type OnlineArchiveApi_GetOnlineArchiveExecute_Call struct { + *mock.Call +} + +// GetOnlineArchiveExecute is a helper method to define mock.On call +// - r admin.GetOnlineArchiveApiRequest +func (_e *OnlineArchiveApi_Expecter) GetOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_GetOnlineArchiveExecute_Call { + return &OnlineArchiveApi_GetOnlineArchiveExecute_Call{Call: _e.mock.On("GetOnlineArchiveExecute", r)} +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveExecute_Call) Run(run func(r admin.GetOnlineArchiveApiRequest)) *OnlineArchiveApi_GetOnlineArchiveExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOnlineArchiveApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveExecute_Call) Return(_a0 *admin.BackupOnlineArchive, _a1 *http.Response, _a2 error) *OnlineArchiveApi_GetOnlineArchiveExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveExecute_Call) RunAndReturn(run func(admin.GetOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_GetOnlineArchiveExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOnlineArchiveWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) GetOnlineArchiveWithParams(ctx context.Context, args *admin.GetOnlineArchiveApiParams) admin.GetOnlineArchiveApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOnlineArchiveWithParams") + } + + var r0 admin.GetOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOnlineArchiveApiParams) admin.GetOnlineArchiveApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_GetOnlineArchiveWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnlineArchiveWithParams' +type OnlineArchiveApi_GetOnlineArchiveWithParams_Call struct { + *mock.Call +} + +// GetOnlineArchiveWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOnlineArchiveApiParams +func (_e *OnlineArchiveApi_Expecter) GetOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call { + return &OnlineArchiveApi_GetOnlineArchiveWithParams_Call{Call: _e.mock.On("GetOnlineArchiveWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOnlineArchiveApiParams)) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOnlineArchiveApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveWithParams_Call) Return(_a0 admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_GetOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOnlineArchiveApiParams) admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOnlineArchives provides a mock function with given fields: ctx, groupId, clusterName +func (_m *OnlineArchiveApi) ListOnlineArchives(ctx context.Context, groupId string, clusterName string) admin.ListOnlineArchivesApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListOnlineArchives") + } + + var r0 admin.ListOnlineArchivesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListOnlineArchivesApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListOnlineArchivesApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_ListOnlineArchives_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOnlineArchives' +type OnlineArchiveApi_ListOnlineArchives_Call struct { + *mock.Call +} + +// ListOnlineArchives is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *OnlineArchiveApi_Expecter) ListOnlineArchives(ctx interface{}, groupId interface{}, clusterName interface{}) *OnlineArchiveApi_ListOnlineArchives_Call { + return &OnlineArchiveApi_ListOnlineArchives_Call{Call: _e.mock.On("ListOnlineArchives", ctx, groupId, clusterName)} +} + +func (_c *OnlineArchiveApi_ListOnlineArchives_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *OnlineArchiveApi_ListOnlineArchives_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchives_Call) Return(_a0 admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchives_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchives_Call) RunAndReturn(run func(context.Context, string, string) admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchives_Call { + _c.Call.Return(run) + return _c +} + +// ListOnlineArchivesExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) ListOnlineArchivesExecute(r admin.ListOnlineArchivesApiRequest) (*admin.PaginatedOnlineArchive, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOnlineArchivesExecute") + } + + var r0 *admin.PaginatedOnlineArchive + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOnlineArchivesApiRequest) (*admin.PaginatedOnlineArchive, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOnlineArchivesApiRequest) *admin.PaginatedOnlineArchive); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedOnlineArchive) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListOnlineArchivesApiRequest) *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.ListOnlineArchivesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_ListOnlineArchivesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOnlineArchivesExecute' +type OnlineArchiveApi_ListOnlineArchivesExecute_Call struct { + *mock.Call +} + +// ListOnlineArchivesExecute is a helper method to define mock.On call +// - r admin.ListOnlineArchivesApiRequest +func (_e *OnlineArchiveApi_Expecter) ListOnlineArchivesExecute(r interface{}) *OnlineArchiveApi_ListOnlineArchivesExecute_Call { + return &OnlineArchiveApi_ListOnlineArchivesExecute_Call{Call: _e.mock.On("ListOnlineArchivesExecute", r)} +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesExecute_Call) Run(run func(r admin.ListOnlineArchivesApiRequest)) *OnlineArchiveApi_ListOnlineArchivesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOnlineArchivesApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesExecute_Call) Return(_a0 *admin.PaginatedOnlineArchive, _a1 *http.Response, _a2 error) *OnlineArchiveApi_ListOnlineArchivesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesExecute_Call) RunAndReturn(run func(admin.ListOnlineArchivesApiRequest) (*admin.PaginatedOnlineArchive, *http.Response, error)) *OnlineArchiveApi_ListOnlineArchivesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOnlineArchivesWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) ListOnlineArchivesWithParams(ctx context.Context, args *admin.ListOnlineArchivesApiParams) admin.ListOnlineArchivesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOnlineArchivesWithParams") + } + + var r0 admin.ListOnlineArchivesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOnlineArchivesApiParams) admin.ListOnlineArchivesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOnlineArchivesApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_ListOnlineArchivesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOnlineArchivesWithParams' +type OnlineArchiveApi_ListOnlineArchivesWithParams_Call struct { + *mock.Call +} + +// ListOnlineArchivesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOnlineArchivesApiParams +func (_e *OnlineArchiveApi_Expecter) ListOnlineArchivesWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call { + return &OnlineArchiveApi_ListOnlineArchivesWithParams_Call{Call: _e.mock.On("ListOnlineArchivesWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOnlineArchivesApiParams)) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOnlineArchivesApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesWithParams_Call) Return(_a0 admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_ListOnlineArchivesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOnlineArchivesApiParams) admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName, backupOnlineArchive +func (_m *OnlineArchiveApi) UpdateOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string, backupOnlineArchive *admin.BackupOnlineArchive) admin.UpdateOnlineArchiveApiRequest { + ret := _m.Called(ctx, groupId, archiveId, clusterName, backupOnlineArchive) + + if len(ret) == 0 { + panic("no return value specified for UpdateOnlineArchive") + } + + var r0 admin.UpdateOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.BackupOnlineArchive) admin.UpdateOnlineArchiveApiRequest); ok { + r0 = rf(ctx, groupId, archiveId, clusterName, backupOnlineArchive) + } else { + r0 = ret.Get(0).(admin.UpdateOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_UpdateOnlineArchive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOnlineArchive' +type OnlineArchiveApi_UpdateOnlineArchive_Call struct { + *mock.Call +} + +// UpdateOnlineArchive is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - archiveId string +// - clusterName string +// - backupOnlineArchive *admin.BackupOnlineArchive +func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchive(ctx interface{}, groupId interface{}, archiveId interface{}, clusterName interface{}, backupOnlineArchive interface{}) *OnlineArchiveApi_UpdateOnlineArchive_Call { + return &OnlineArchiveApi_UpdateOnlineArchive_Call{Call: _e.mock.On("UpdateOnlineArchive", ctx, groupId, archiveId, clusterName, backupOnlineArchive)} +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string, backupOnlineArchive *admin.BackupOnlineArchive)) *OnlineArchiveApi_UpdateOnlineArchive_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.BackupOnlineArchive)) + }) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) Return(_a0 admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchive_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupOnlineArchive) admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchive_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOnlineArchiveExecute provides a mock function with given fields: r +func (_m *OnlineArchiveApi) UpdateOnlineArchiveExecute(r admin.UpdateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateOnlineArchiveExecute") + } + + var r0 *admin.BackupOnlineArchive + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateOnlineArchiveApiRequest) *admin.BackupOnlineArchive); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupOnlineArchive) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateOnlineArchiveApiRequest) *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.UpdateOnlineArchiveApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OnlineArchiveApi_UpdateOnlineArchiveExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOnlineArchiveExecute' +type OnlineArchiveApi_UpdateOnlineArchiveExecute_Call struct { + *mock.Call +} + +// UpdateOnlineArchiveExecute is a helper method to define mock.On call +// - r admin.UpdateOnlineArchiveApiRequest +func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call { + return &OnlineArchiveApi_UpdateOnlineArchiveExecute_Call{Call: _e.mock.On("UpdateOnlineArchiveExecute", r)} +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call) Run(run func(r admin.UpdateOnlineArchiveApiRequest)) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateOnlineArchiveApiRequest)) + }) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call) Return(_a0 *admin.BackupOnlineArchive, _a1 *http.Response, _a2 error) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call) RunAndReturn(run func(admin.UpdateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOnlineArchiveWithParams provides a mock function with given fields: ctx, args +func (_m *OnlineArchiveApi) UpdateOnlineArchiveWithParams(ctx context.Context, args *admin.UpdateOnlineArchiveApiParams) admin.UpdateOnlineArchiveApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateOnlineArchiveWithParams") + } + + var r0 admin.UpdateOnlineArchiveApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateOnlineArchiveApiParams) admin.UpdateOnlineArchiveApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateOnlineArchiveApiRequest) + } + + return r0 +} + +// OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOnlineArchiveWithParams' +type OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call struct { + *mock.Call +} + +// UpdateOnlineArchiveWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateOnlineArchiveApiParams +func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call { + return &OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call{Call: _e.mock.On("UpdateOnlineArchiveWithParams", ctx, args)} +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateOnlineArchiveApiParams)) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateOnlineArchiveApiParams)) + }) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call) Return(_a0 admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOnlineArchiveApiParams) admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewOnlineArchiveApi creates a new instance of OnlineArchiveApi. 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 NewOnlineArchiveApi(t interface { + mock.TestingT + Cleanup(func()) +}) *OnlineArchiveApi { + mock := &OnlineArchiveApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/organizations_api.go b/mockadmin/organizations_api.go new file mode 100644 index 000000000..82386f1a1 --- /dev/null +++ b/mockadmin/organizations_api.go @@ -0,0 +1,2787 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// OrganizationsApi is an autogenerated mock type for the OrganizationsApi type +type OrganizationsApi struct { + mock.Mock +} + +type OrganizationsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *OrganizationsApi) EXPECT() *OrganizationsApi_Expecter { + return &OrganizationsApi_Expecter{mock: &_m.Mock} +} + +// CreateOrganization provides a mock function with given fields: ctx, createOrganizationRequest +func (_m *OrganizationsApi) CreateOrganization(ctx context.Context, createOrganizationRequest *admin.CreateOrganizationRequest) admin.CreateOrganizationApiRequest { + ret := _m.Called(ctx, createOrganizationRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganization") + } + + var r0 admin.CreateOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOrganizationRequest) admin.CreateOrganizationApiRequest); ok { + r0 = rf(ctx, createOrganizationRequest) + } else { + r0 = ret.Get(0).(admin.CreateOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_CreateOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganization' +type OrganizationsApi_CreateOrganization_Call struct { + *mock.Call +} + +// CreateOrganization is a helper method to define mock.On call +// - ctx context.Context +// - createOrganizationRequest *admin.CreateOrganizationRequest +func (_e *OrganizationsApi_Expecter) CreateOrganization(ctx interface{}, createOrganizationRequest interface{}) *OrganizationsApi_CreateOrganization_Call { + return &OrganizationsApi_CreateOrganization_Call{Call: _e.mock.On("CreateOrganization", ctx, createOrganizationRequest)} +} + +func (_c *OrganizationsApi_CreateOrganization_Call) Run(run func(ctx context.Context, createOrganizationRequest *admin.CreateOrganizationRequest)) *OrganizationsApi_CreateOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateOrganizationRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganization_Call) Return(_a0 admin.CreateOrganizationApiRequest) *OrganizationsApi_CreateOrganization_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_CreateOrganization_Call) RunAndReturn(run func(context.Context, *admin.CreateOrganizationRequest) admin.CreateOrganizationApiRequest) *OrganizationsApi_CreateOrganization_Call { + _c.Call.Return(run) + return _c +} + +// CreateOrganizationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) CreateOrganizationExecute(r admin.CreateOrganizationApiRequest) (*admin.CreateOrganizationResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganizationExecute") + } + + var r0 *admin.CreateOrganizationResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateOrganizationApiRequest) (*admin.CreateOrganizationResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateOrganizationApiRequest) *admin.CreateOrganizationResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.CreateOrganizationResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateOrganizationApiRequest) *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.CreateOrganizationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_CreateOrganizationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganizationExecute' +type OrganizationsApi_CreateOrganizationExecute_Call struct { + *mock.Call +} + +// CreateOrganizationExecute is a helper method to define mock.On call +// - r admin.CreateOrganizationApiRequest +func (_e *OrganizationsApi_Expecter) CreateOrganizationExecute(r interface{}) *OrganizationsApi_CreateOrganizationExecute_Call { + return &OrganizationsApi_CreateOrganizationExecute_Call{Call: _e.mock.On("CreateOrganizationExecute", r)} +} + +func (_c *OrganizationsApi_CreateOrganizationExecute_Call) Run(run func(r admin.CreateOrganizationApiRequest)) *OrganizationsApi_CreateOrganizationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateOrganizationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationExecute_Call) Return(_a0 *admin.CreateOrganizationResponse, _a1 *http.Response, _a2 error) *OrganizationsApi_CreateOrganizationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationExecute_Call) RunAndReturn(run func(admin.CreateOrganizationApiRequest) (*admin.CreateOrganizationResponse, *http.Response, error)) *OrganizationsApi_CreateOrganizationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateOrganizationInvitation provides a mock function with given fields: ctx, orgId, organizationInvitationRequest +func (_m *OrganizationsApi) CreateOrganizationInvitation(ctx context.Context, orgId string, organizationInvitationRequest *admin.OrganizationInvitationRequest) admin.CreateOrganizationInvitationApiRequest { + ret := _m.Called(ctx, orgId, organizationInvitationRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganizationInvitation") + } + + var r0 admin.CreateOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.OrganizationInvitationRequest) admin.CreateOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, orgId, organizationInvitationRequest) + } else { + r0 = ret.Get(0).(admin.CreateOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_CreateOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganizationInvitation' +type OrganizationsApi_CreateOrganizationInvitation_Call struct { + *mock.Call +} + +// CreateOrganizationInvitation is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - organizationInvitationRequest *admin.OrganizationInvitationRequest +func (_e *OrganizationsApi_Expecter) CreateOrganizationInvitation(ctx interface{}, orgId interface{}, organizationInvitationRequest interface{}) *OrganizationsApi_CreateOrganizationInvitation_Call { + return &OrganizationsApi_CreateOrganizationInvitation_Call{Call: _e.mock.On("CreateOrganizationInvitation", ctx, orgId, organizationInvitationRequest)} +} + +func (_c *OrganizationsApi_CreateOrganizationInvitation_Call) Run(run func(ctx context.Context, orgId string, organizationInvitationRequest *admin.OrganizationInvitationRequest)) *OrganizationsApi_CreateOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.OrganizationInvitationRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitation_Call) Return(_a0 admin.CreateOrganizationInvitationApiRequest) *OrganizationsApi_CreateOrganizationInvitation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitation_Call) RunAndReturn(run func(context.Context, string, *admin.OrganizationInvitationRequest) admin.CreateOrganizationInvitationApiRequest) *OrganizationsApi_CreateOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// CreateOrganizationInvitationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) CreateOrganizationInvitationExecute(r admin.CreateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganizationInvitationExecute") + } + + var r0 *admin.OrganizationInvitation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateOrganizationInvitationApiRequest) *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.CreateOrganizationInvitationApiRequest) *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.CreateOrganizationInvitationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_CreateOrganizationInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganizationInvitationExecute' +type OrganizationsApi_CreateOrganizationInvitationExecute_Call struct { + *mock.Call +} + +// CreateOrganizationInvitationExecute is a helper method to define mock.On call +// - r admin.CreateOrganizationInvitationApiRequest +func (_e *OrganizationsApi_Expecter) CreateOrganizationInvitationExecute(r interface{}) *OrganizationsApi_CreateOrganizationInvitationExecute_Call { + return &OrganizationsApi_CreateOrganizationInvitationExecute_Call{Call: _e.mock.On("CreateOrganizationInvitationExecute", r)} +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationExecute_Call) Run(run func(r admin.CreateOrganizationInvitationApiRequest)) *OrganizationsApi_CreateOrganizationInvitationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateOrganizationInvitationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationExecute_Call) Return(_a0 *admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *OrganizationsApi_CreateOrganizationInvitationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationExecute_Call) RunAndReturn(run func(admin.CreateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)) *OrganizationsApi_CreateOrganizationInvitationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateOrganizationInvitationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) CreateOrganizationInvitationWithParams(ctx context.Context, args *admin.CreateOrganizationInvitationApiParams) admin.CreateOrganizationInvitationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganizationInvitationWithParams") + } + + var r0 admin.CreateOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOrganizationInvitationApiParams) admin.CreateOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_CreateOrganizationInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganizationInvitationWithParams' +type OrganizationsApi_CreateOrganizationInvitationWithParams_Call struct { + *mock.Call +} + +// CreateOrganizationInvitationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateOrganizationInvitationApiParams +func (_e *OrganizationsApi_Expecter) CreateOrganizationInvitationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_CreateOrganizationInvitationWithParams_Call { + return &OrganizationsApi_CreateOrganizationInvitationWithParams_Call{Call: _e.mock.On("CreateOrganizationInvitationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateOrganizationInvitationApiParams)) *OrganizationsApi_CreateOrganizationInvitationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateOrganizationInvitationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationWithParams_Call) Return(_a0 admin.CreateOrganizationInvitationApiRequest) *OrganizationsApi_CreateOrganizationInvitationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOrganizationInvitationApiParams) admin.CreateOrganizationInvitationApiRequest) *OrganizationsApi_CreateOrganizationInvitationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateOrganizationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) CreateOrganizationWithParams(ctx context.Context, args *admin.CreateOrganizationApiParams) admin.CreateOrganizationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateOrganizationWithParams") + } + + var r0 admin.CreateOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOrganizationApiParams) admin.CreateOrganizationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_CreateOrganizationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOrganizationWithParams' +type OrganizationsApi_CreateOrganizationWithParams_Call struct { + *mock.Call +} + +// CreateOrganizationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateOrganizationApiParams +func (_e *OrganizationsApi_Expecter) CreateOrganizationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_CreateOrganizationWithParams_Call { + return &OrganizationsApi_CreateOrganizationWithParams_Call{Call: _e.mock.On("CreateOrganizationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_CreateOrganizationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateOrganizationApiParams)) *OrganizationsApi_CreateOrganizationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateOrganizationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationWithParams_Call) Return(_a0 admin.CreateOrganizationApiRequest) *OrganizationsApi_CreateOrganizationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_CreateOrganizationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOrganizationApiParams) admin.CreateOrganizationApiRequest) *OrganizationsApi_CreateOrganizationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganization provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) DeleteOrganization(ctx context.Context, orgId string) admin.DeleteOrganizationApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganization") + } + + var r0 admin.DeleteOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteOrganizationApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.DeleteOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_DeleteOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganization' +type OrganizationsApi_DeleteOrganization_Call struct { + *mock.Call +} + +// DeleteOrganization is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) DeleteOrganization(ctx interface{}, orgId interface{}) *OrganizationsApi_DeleteOrganization_Call { + return &OrganizationsApi_DeleteOrganization_Call{Call: _e.mock.On("DeleteOrganization", ctx, orgId)} +} + +func (_c *OrganizationsApi_DeleteOrganization_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_DeleteOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganization_Call) Return(_a0 admin.DeleteOrganizationApiRequest) *OrganizationsApi_DeleteOrganization_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganization_Call) RunAndReturn(run func(context.Context, string) admin.DeleteOrganizationApiRequest) *OrganizationsApi_DeleteOrganization_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganizationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) DeleteOrganizationExecute(r admin.DeleteOrganizationApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganizationExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteOrganizationApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteOrganizationApiRequest) 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.DeleteOrganizationApiRequest) *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.DeleteOrganizationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_DeleteOrganizationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizationExecute' +type OrganizationsApi_DeleteOrganizationExecute_Call struct { + *mock.Call +} + +// DeleteOrganizationExecute is a helper method to define mock.On call +// - r admin.DeleteOrganizationApiRequest +func (_e *OrganizationsApi_Expecter) DeleteOrganizationExecute(r interface{}) *OrganizationsApi_DeleteOrganizationExecute_Call { + return &OrganizationsApi_DeleteOrganizationExecute_Call{Call: _e.mock.On("DeleteOrganizationExecute", r)} +} + +func (_c *OrganizationsApi_DeleteOrganizationExecute_Call) Run(run func(r admin.DeleteOrganizationApiRequest)) *OrganizationsApi_DeleteOrganizationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteOrganizationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *OrganizationsApi_DeleteOrganizationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationExecute_Call) RunAndReturn(run func(admin.DeleteOrganizationApiRequest) (map[string]interface{}, *http.Response, error)) *OrganizationsApi_DeleteOrganizationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganizationInvitation provides a mock function with given fields: ctx, orgId, invitationId +func (_m *OrganizationsApi) DeleteOrganizationInvitation(ctx context.Context, orgId string, invitationId string) admin.DeleteOrganizationInvitationApiRequest { + ret := _m.Called(ctx, orgId, invitationId) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganizationInvitation") + } + + var r0 admin.DeleteOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, orgId, invitationId) + } else { + r0 = ret.Get(0).(admin.DeleteOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_DeleteOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizationInvitation' +type OrganizationsApi_DeleteOrganizationInvitation_Call struct { + *mock.Call +} + +// DeleteOrganizationInvitation is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - invitationId string +func (_e *OrganizationsApi_Expecter) DeleteOrganizationInvitation(ctx interface{}, orgId interface{}, invitationId interface{}) *OrganizationsApi_DeleteOrganizationInvitation_Call { + return &OrganizationsApi_DeleteOrganizationInvitation_Call{Call: _e.mock.On("DeleteOrganizationInvitation", ctx, orgId, invitationId)} +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitation_Call) Run(run func(ctx context.Context, orgId string, invitationId string)) *OrganizationsApi_DeleteOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitation_Call) Return(_a0 admin.DeleteOrganizationInvitationApiRequest) *OrganizationsApi_DeleteOrganizationInvitation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitation_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteOrganizationInvitationApiRequest) *OrganizationsApi_DeleteOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganizationInvitationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) DeleteOrganizationInvitationExecute(r admin.DeleteOrganizationInvitationApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganizationInvitationExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteOrganizationInvitationApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteOrganizationInvitationApiRequest) 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.DeleteOrganizationInvitationApiRequest) *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.DeleteOrganizationInvitationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_DeleteOrganizationInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizationInvitationExecute' +type OrganizationsApi_DeleteOrganizationInvitationExecute_Call struct { + *mock.Call +} + +// DeleteOrganizationInvitationExecute is a helper method to define mock.On call +// - r admin.DeleteOrganizationInvitationApiRequest +func (_e *OrganizationsApi_Expecter) DeleteOrganizationInvitationExecute(r interface{}) *OrganizationsApi_DeleteOrganizationInvitationExecute_Call { + return &OrganizationsApi_DeleteOrganizationInvitationExecute_Call{Call: _e.mock.On("DeleteOrganizationInvitationExecute", r)} +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationExecute_Call) Run(run func(r admin.DeleteOrganizationInvitationApiRequest)) *OrganizationsApi_DeleteOrganizationInvitationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteOrganizationInvitationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *OrganizationsApi_DeleteOrganizationInvitationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationExecute_Call) RunAndReturn(run func(admin.DeleteOrganizationInvitationApiRequest) (map[string]interface{}, *http.Response, error)) *OrganizationsApi_DeleteOrganizationInvitationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganizationInvitationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) DeleteOrganizationInvitationWithParams(ctx context.Context, args *admin.DeleteOrganizationInvitationApiParams) admin.DeleteOrganizationInvitationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganizationInvitationWithParams") + } + + var r0 admin.DeleteOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteOrganizationInvitationApiParams) admin.DeleteOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_DeleteOrganizationInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizationInvitationWithParams' +type OrganizationsApi_DeleteOrganizationInvitationWithParams_Call struct { + *mock.Call +} + +// DeleteOrganizationInvitationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteOrganizationInvitationApiParams +func (_e *OrganizationsApi_Expecter) DeleteOrganizationInvitationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call { + return &OrganizationsApi_DeleteOrganizationInvitationWithParams_Call{Call: _e.mock.On("DeleteOrganizationInvitationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteOrganizationInvitationApiParams)) *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteOrganizationInvitationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call) Return(_a0 admin.DeleteOrganizationInvitationApiRequest) *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOrganizationInvitationApiParams) admin.DeleteOrganizationInvitationApiRequest) *OrganizationsApi_DeleteOrganizationInvitationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOrganizationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) DeleteOrganizationWithParams(ctx context.Context, args *admin.DeleteOrganizationApiParams) admin.DeleteOrganizationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteOrganizationWithParams") + } + + var r0 admin.DeleteOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteOrganizationApiParams) admin.DeleteOrganizationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_DeleteOrganizationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOrganizationWithParams' +type OrganizationsApi_DeleteOrganizationWithParams_Call struct { + *mock.Call +} + +// DeleteOrganizationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteOrganizationApiParams +func (_e *OrganizationsApi_Expecter) DeleteOrganizationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_DeleteOrganizationWithParams_Call { + return &OrganizationsApi_DeleteOrganizationWithParams_Call{Call: _e.mock.On("DeleteOrganizationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_DeleteOrganizationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteOrganizationApiParams)) *OrganizationsApi_DeleteOrganizationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteOrganizationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationWithParams_Call) Return(_a0 admin.DeleteOrganizationApiRequest) *OrganizationsApi_DeleteOrganizationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_DeleteOrganizationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOrganizationApiParams) admin.DeleteOrganizationApiRequest) *OrganizationsApi_DeleteOrganizationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganization provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) GetOrganization(ctx context.Context, orgId string) admin.GetOrganizationApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for GetOrganization") + } + + var r0 admin.GetOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetOrganizationApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.GetOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganization' +type OrganizationsApi_GetOrganization_Call struct { + *mock.Call +} + +// GetOrganization is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) GetOrganization(ctx interface{}, orgId interface{}) *OrganizationsApi_GetOrganization_Call { + return &OrganizationsApi_GetOrganization_Call{Call: _e.mock.On("GetOrganization", ctx, orgId)} +} + +func (_c *OrganizationsApi_GetOrganization_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_GetOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganization_Call) Return(_a0 admin.GetOrganizationApiRequest) *OrganizationsApi_GetOrganization_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganization_Call) RunAndReturn(run func(context.Context, string) admin.GetOrganizationApiRequest) *OrganizationsApi_GetOrganization_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) GetOrganizationExecute(r admin.GetOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationExecute") + } + + var r0 *admin.AtlasOrganization + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOrganizationApiRequest) *admin.AtlasOrganization); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AtlasOrganization) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetOrganizationApiRequest) *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.GetOrganizationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_GetOrganizationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationExecute' +type OrganizationsApi_GetOrganizationExecute_Call struct { + *mock.Call +} + +// GetOrganizationExecute is a helper method to define mock.On call +// - r admin.GetOrganizationApiRequest +func (_e *OrganizationsApi_Expecter) GetOrganizationExecute(r interface{}) *OrganizationsApi_GetOrganizationExecute_Call { + return &OrganizationsApi_GetOrganizationExecute_Call{Call: _e.mock.On("GetOrganizationExecute", r)} +} + +func (_c *OrganizationsApi_GetOrganizationExecute_Call) Run(run func(r admin.GetOrganizationApiRequest)) *OrganizationsApi_GetOrganizationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOrganizationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationExecute_Call) Return(_a0 *admin.AtlasOrganization, _a1 *http.Response, _a2 error) *OrganizationsApi_GetOrganizationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationExecute_Call) RunAndReturn(run func(admin.GetOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error)) *OrganizationsApi_GetOrganizationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationInvitation provides a mock function with given fields: ctx, orgId, invitationId +func (_m *OrganizationsApi) GetOrganizationInvitation(ctx context.Context, orgId string, invitationId string) admin.GetOrganizationInvitationApiRequest { + ret := _m.Called(ctx, orgId, invitationId) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationInvitation") + } + + var r0 admin.GetOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, orgId, invitationId) + } else { + r0 = ret.Get(0).(admin.GetOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationInvitation' +type OrganizationsApi_GetOrganizationInvitation_Call struct { + *mock.Call +} + +// GetOrganizationInvitation is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - invitationId string +func (_e *OrganizationsApi_Expecter) GetOrganizationInvitation(ctx interface{}, orgId interface{}, invitationId interface{}) *OrganizationsApi_GetOrganizationInvitation_Call { + return &OrganizationsApi_GetOrganizationInvitation_Call{Call: _e.mock.On("GetOrganizationInvitation", ctx, orgId, invitationId)} +} + +func (_c *OrganizationsApi_GetOrganizationInvitation_Call) Run(run func(ctx context.Context, orgId string, invitationId string)) *OrganizationsApi_GetOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitation_Call) Return(_a0 admin.GetOrganizationInvitationApiRequest) *OrganizationsApi_GetOrganizationInvitation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitation_Call) RunAndReturn(run func(context.Context, string, string) admin.GetOrganizationInvitationApiRequest) *OrganizationsApi_GetOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationInvitationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) GetOrganizationInvitationExecute(r admin.GetOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationInvitationExecute") + } + + var r0 *admin.OrganizationInvitation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOrganizationInvitationApiRequest) *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.GetOrganizationInvitationApiRequest) *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.GetOrganizationInvitationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_GetOrganizationInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationInvitationExecute' +type OrganizationsApi_GetOrganizationInvitationExecute_Call struct { + *mock.Call +} + +// GetOrganizationInvitationExecute is a helper method to define mock.On call +// - r admin.GetOrganizationInvitationApiRequest +func (_e *OrganizationsApi_Expecter) GetOrganizationInvitationExecute(r interface{}) *OrganizationsApi_GetOrganizationInvitationExecute_Call { + return &OrganizationsApi_GetOrganizationInvitationExecute_Call{Call: _e.mock.On("GetOrganizationInvitationExecute", r)} +} + +func (_c *OrganizationsApi_GetOrganizationInvitationExecute_Call) Run(run func(r admin.GetOrganizationInvitationApiRequest)) *OrganizationsApi_GetOrganizationInvitationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOrganizationInvitationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitationExecute_Call) Return(_a0 *admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *OrganizationsApi_GetOrganizationInvitationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitationExecute_Call) RunAndReturn(run func(admin.GetOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)) *OrganizationsApi_GetOrganizationInvitationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationInvitationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) GetOrganizationInvitationWithParams(ctx context.Context, args *admin.GetOrganizationInvitationApiParams) admin.GetOrganizationInvitationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationInvitationWithParams") + } + + var r0 admin.GetOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOrganizationInvitationApiParams) admin.GetOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganizationInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationInvitationWithParams' +type OrganizationsApi_GetOrganizationInvitationWithParams_Call struct { + *mock.Call +} + +// GetOrganizationInvitationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOrganizationInvitationApiParams +func (_e *OrganizationsApi_Expecter) GetOrganizationInvitationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_GetOrganizationInvitationWithParams_Call { + return &OrganizationsApi_GetOrganizationInvitationWithParams_Call{Call: _e.mock.On("GetOrganizationInvitationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_GetOrganizationInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOrganizationInvitationApiParams)) *OrganizationsApi_GetOrganizationInvitationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOrganizationInvitationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitationWithParams_Call) Return(_a0 admin.GetOrganizationInvitationApiRequest) *OrganizationsApi_GetOrganizationInvitationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOrganizationInvitationApiParams) admin.GetOrganizationInvitationApiRequest) *OrganizationsApi_GetOrganizationInvitationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationSettings provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) GetOrganizationSettings(ctx context.Context, orgId string) admin.GetOrganizationSettingsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationSettings") + } + + var r0 admin.GetOrganizationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetOrganizationSettingsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.GetOrganizationSettingsApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganizationSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationSettings' +type OrganizationsApi_GetOrganizationSettings_Call struct { + *mock.Call +} + +// GetOrganizationSettings is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) GetOrganizationSettings(ctx interface{}, orgId interface{}) *OrganizationsApi_GetOrganizationSettings_Call { + return &OrganizationsApi_GetOrganizationSettings_Call{Call: _e.mock.On("GetOrganizationSettings", ctx, orgId)} +} + +func (_c *OrganizationsApi_GetOrganizationSettings_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_GetOrganizationSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettings_Call) Return(_a0 admin.GetOrganizationSettingsApiRequest) *OrganizationsApi_GetOrganizationSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettings_Call) RunAndReturn(run func(context.Context, string) admin.GetOrganizationSettingsApiRequest) *OrganizationsApi_GetOrganizationSettings_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationSettingsExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) GetOrganizationSettingsExecute(r admin.GetOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationSettingsExecute") + } + + var r0 *admin.OrganizationSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetOrganizationSettingsApiRequest) *admin.OrganizationSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.OrganizationSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetOrganizationSettingsApiRequest) *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.GetOrganizationSettingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_GetOrganizationSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationSettingsExecute' +type OrganizationsApi_GetOrganizationSettingsExecute_Call struct { + *mock.Call +} + +// GetOrganizationSettingsExecute is a helper method to define mock.On call +// - r admin.GetOrganizationSettingsApiRequest +func (_e *OrganizationsApi_Expecter) GetOrganizationSettingsExecute(r interface{}) *OrganizationsApi_GetOrganizationSettingsExecute_Call { + return &OrganizationsApi_GetOrganizationSettingsExecute_Call{Call: _e.mock.On("GetOrganizationSettingsExecute", r)} +} + +func (_c *OrganizationsApi_GetOrganizationSettingsExecute_Call) Run(run func(r admin.GetOrganizationSettingsApiRequest)) *OrganizationsApi_GetOrganizationSettingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetOrganizationSettingsApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettingsExecute_Call) Return(_a0 *admin.OrganizationSettings, _a1 *http.Response, _a2 error) *OrganizationsApi_GetOrganizationSettingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettingsExecute_Call) RunAndReturn(run func(admin.GetOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error)) *OrganizationsApi_GetOrganizationSettingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationSettingsWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) GetOrganizationSettingsWithParams(ctx context.Context, args *admin.GetOrganizationSettingsApiParams) admin.GetOrganizationSettingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationSettingsWithParams") + } + + var r0 admin.GetOrganizationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOrganizationSettingsApiParams) admin.GetOrganizationSettingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOrganizationSettingsApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganizationSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationSettingsWithParams' +type OrganizationsApi_GetOrganizationSettingsWithParams_Call struct { + *mock.Call +} + +// GetOrganizationSettingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOrganizationSettingsApiParams +func (_e *OrganizationsApi_Expecter) GetOrganizationSettingsWithParams(ctx interface{}, args interface{}) *OrganizationsApi_GetOrganizationSettingsWithParams_Call { + return &OrganizationsApi_GetOrganizationSettingsWithParams_Call{Call: _e.mock.On("GetOrganizationSettingsWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_GetOrganizationSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOrganizationSettingsApiParams)) *OrganizationsApi_GetOrganizationSettingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOrganizationSettingsApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettingsWithParams_Call) Return(_a0 admin.GetOrganizationSettingsApiRequest) *OrganizationsApi_GetOrganizationSettingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOrganizationSettingsApiParams) admin.GetOrganizationSettingsApiRequest) *OrganizationsApi_GetOrganizationSettingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) GetOrganizationWithParams(ctx context.Context, args *admin.GetOrganizationApiParams) admin.GetOrganizationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationWithParams") + } + + var r0 admin.GetOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetOrganizationApiParams) admin.GetOrganizationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_GetOrganizationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationWithParams' +type OrganizationsApi_GetOrganizationWithParams_Call struct { + *mock.Call +} + +// GetOrganizationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetOrganizationApiParams +func (_e *OrganizationsApi_Expecter) GetOrganizationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_GetOrganizationWithParams_Call { + return &OrganizationsApi_GetOrganizationWithParams_Call{Call: _e.mock.On("GetOrganizationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_GetOrganizationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetOrganizationApiParams)) *OrganizationsApi_GetOrganizationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetOrganizationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationWithParams_Call) Return(_a0 admin.GetOrganizationApiRequest) *OrganizationsApi_GetOrganizationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_GetOrganizationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOrganizationApiParams) admin.GetOrganizationApiRequest) *OrganizationsApi_GetOrganizationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationInvitations provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) ListOrganizationInvitations(ctx context.Context, orgId string) admin.ListOrganizationInvitationsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationInvitations") + } + + var r0 admin.ListOrganizationInvitationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationInvitationsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListOrganizationInvitationsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationInvitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationInvitations' +type OrganizationsApi_ListOrganizationInvitations_Call struct { + *mock.Call +} + +// ListOrganizationInvitations is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) ListOrganizationInvitations(ctx interface{}, orgId interface{}) *OrganizationsApi_ListOrganizationInvitations_Call { + return &OrganizationsApi_ListOrganizationInvitations_Call{Call: _e.mock.On("ListOrganizationInvitations", ctx, orgId)} +} + +func (_c *OrganizationsApi_ListOrganizationInvitations_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_ListOrganizationInvitations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitations_Call) Return(_a0 admin.ListOrganizationInvitationsApiRequest) *OrganizationsApi_ListOrganizationInvitations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitations_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationInvitationsApiRequest) *OrganizationsApi_ListOrganizationInvitations_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationInvitationsExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) ListOrganizationInvitationsExecute(r admin.ListOrganizationInvitationsApiRequest) ([]admin.OrganizationInvitation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationInvitationsExecute") + } + + var r0 []admin.OrganizationInvitation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOrganizationInvitationsApiRequest) ([]admin.OrganizationInvitation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOrganizationInvitationsApiRequest) []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.ListOrganizationInvitationsApiRequest) *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.ListOrganizationInvitationsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_ListOrganizationInvitationsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationInvitationsExecute' +type OrganizationsApi_ListOrganizationInvitationsExecute_Call struct { + *mock.Call +} + +// ListOrganizationInvitationsExecute is a helper method to define mock.On call +// - r admin.ListOrganizationInvitationsApiRequest +func (_e *OrganizationsApi_Expecter) ListOrganizationInvitationsExecute(r interface{}) *OrganizationsApi_ListOrganizationInvitationsExecute_Call { + return &OrganizationsApi_ListOrganizationInvitationsExecute_Call{Call: _e.mock.On("ListOrganizationInvitationsExecute", r)} +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsExecute_Call) Run(run func(r admin.ListOrganizationInvitationsApiRequest)) *OrganizationsApi_ListOrganizationInvitationsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOrganizationInvitationsApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsExecute_Call) Return(_a0 []admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *OrganizationsApi_ListOrganizationInvitationsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsExecute_Call) RunAndReturn(run func(admin.ListOrganizationInvitationsApiRequest) ([]admin.OrganizationInvitation, *http.Response, error)) *OrganizationsApi_ListOrganizationInvitationsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationInvitationsWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) ListOrganizationInvitationsWithParams(ctx context.Context, args *admin.ListOrganizationInvitationsApiParams) admin.ListOrganizationInvitationsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationInvitationsWithParams") + } + + var r0 admin.ListOrganizationInvitationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationInvitationsApiParams) admin.ListOrganizationInvitationsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOrganizationInvitationsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationInvitationsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationInvitationsWithParams' +type OrganizationsApi_ListOrganizationInvitationsWithParams_Call struct { + *mock.Call +} + +// ListOrganizationInvitationsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOrganizationInvitationsApiParams +func (_e *OrganizationsApi_Expecter) ListOrganizationInvitationsWithParams(ctx interface{}, args interface{}) *OrganizationsApi_ListOrganizationInvitationsWithParams_Call { + return &OrganizationsApi_ListOrganizationInvitationsWithParams_Call{Call: _e.mock.On("ListOrganizationInvitationsWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationInvitationsApiParams)) *OrganizationsApi_ListOrganizationInvitationsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOrganizationInvitationsApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsWithParams_Call) Return(_a0 admin.ListOrganizationInvitationsApiRequest) *OrganizationsApi_ListOrganizationInvitationsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationInvitationsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationInvitationsApiParams) admin.ListOrganizationInvitationsApiRequest) *OrganizationsApi_ListOrganizationInvitationsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationProjects provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) ListOrganizationProjects(ctx context.Context, orgId string) admin.ListOrganizationProjectsApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationProjects") + } + + var r0 admin.ListOrganizationProjectsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationProjectsApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListOrganizationProjectsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationProjects' +type OrganizationsApi_ListOrganizationProjects_Call struct { + *mock.Call +} + +// ListOrganizationProjects is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) ListOrganizationProjects(ctx interface{}, orgId interface{}) *OrganizationsApi_ListOrganizationProjects_Call { + return &OrganizationsApi_ListOrganizationProjects_Call{Call: _e.mock.On("ListOrganizationProjects", ctx, orgId)} +} + +func (_c *OrganizationsApi_ListOrganizationProjects_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_ListOrganizationProjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjects_Call) Return(_a0 admin.ListOrganizationProjectsApiRequest) *OrganizationsApi_ListOrganizationProjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjects_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationProjectsApiRequest) *OrganizationsApi_ListOrganizationProjects_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationProjectsExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) ListOrganizationProjectsExecute(r admin.ListOrganizationProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationProjectsExecute") + } + + var r0 *admin.PaginatedAtlasGroup + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOrganizationProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOrganizationProjectsApiRequest) *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.ListOrganizationProjectsApiRequest) *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.ListOrganizationProjectsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_ListOrganizationProjectsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationProjectsExecute' +type OrganizationsApi_ListOrganizationProjectsExecute_Call struct { + *mock.Call +} + +// ListOrganizationProjectsExecute is a helper method to define mock.On call +// - r admin.ListOrganizationProjectsApiRequest +func (_e *OrganizationsApi_Expecter) ListOrganizationProjectsExecute(r interface{}) *OrganizationsApi_ListOrganizationProjectsExecute_Call { + return &OrganizationsApi_ListOrganizationProjectsExecute_Call{Call: _e.mock.On("ListOrganizationProjectsExecute", r)} +} + +func (_c *OrganizationsApi_ListOrganizationProjectsExecute_Call) Run(run func(r admin.ListOrganizationProjectsApiRequest)) *OrganizationsApi_ListOrganizationProjectsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOrganizationProjectsApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjectsExecute_Call) Return(_a0 *admin.PaginatedAtlasGroup, _a1 *http.Response, _a2 error) *OrganizationsApi_ListOrganizationProjectsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjectsExecute_Call) RunAndReturn(run func(admin.ListOrganizationProjectsApiRequest) (*admin.PaginatedAtlasGroup, *http.Response, error)) *OrganizationsApi_ListOrganizationProjectsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationProjectsWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) ListOrganizationProjectsWithParams(ctx context.Context, args *admin.ListOrganizationProjectsApiParams) admin.ListOrganizationProjectsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationProjectsWithParams") + } + + var r0 admin.ListOrganizationProjectsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationProjectsApiParams) admin.ListOrganizationProjectsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOrganizationProjectsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationProjectsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationProjectsWithParams' +type OrganizationsApi_ListOrganizationProjectsWithParams_Call struct { + *mock.Call +} + +// ListOrganizationProjectsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOrganizationProjectsApiParams +func (_e *OrganizationsApi_Expecter) ListOrganizationProjectsWithParams(ctx interface{}, args interface{}) *OrganizationsApi_ListOrganizationProjectsWithParams_Call { + return &OrganizationsApi_ListOrganizationProjectsWithParams_Call{Call: _e.mock.On("ListOrganizationProjectsWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_ListOrganizationProjectsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationProjectsApiParams)) *OrganizationsApi_ListOrganizationProjectsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOrganizationProjectsApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjectsWithParams_Call) Return(_a0 admin.ListOrganizationProjectsApiRequest) *OrganizationsApi_ListOrganizationProjectsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationProjectsApiParams) admin.ListOrganizationProjectsApiRequest) *OrganizationsApi_ListOrganizationProjectsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationUsers provides a mock function with given fields: ctx, orgId +func (_m *OrganizationsApi) ListOrganizationUsers(ctx context.Context, orgId string) admin.ListOrganizationUsersApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationUsers") + } + + var r0 admin.ListOrganizationUsersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationUsersApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListOrganizationUsersApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationUsers' +type OrganizationsApi_ListOrganizationUsers_Call struct { + *mock.Call +} + +// ListOrganizationUsers is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *OrganizationsApi_Expecter) ListOrganizationUsers(ctx interface{}, orgId interface{}) *OrganizationsApi_ListOrganizationUsers_Call { + return &OrganizationsApi_ListOrganizationUsers_Call{Call: _e.mock.On("ListOrganizationUsers", ctx, orgId)} +} + +func (_c *OrganizationsApi_ListOrganizationUsers_Call) Run(run func(ctx context.Context, orgId string)) *OrganizationsApi_ListOrganizationUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsers_Call) Return(_a0 admin.ListOrganizationUsersApiRequest) *OrganizationsApi_ListOrganizationUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsers_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationUsersApiRequest) *OrganizationsApi_ListOrganizationUsers_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationUsersExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) ListOrganizationUsersExecute(r admin.ListOrganizationUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationUsersExecute") + } + + var r0 *admin.PaginatedAppUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOrganizationUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOrganizationUsersApiRequest) *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.ListOrganizationUsersApiRequest) *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.ListOrganizationUsersApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_ListOrganizationUsersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationUsersExecute' +type OrganizationsApi_ListOrganizationUsersExecute_Call struct { + *mock.Call +} + +// ListOrganizationUsersExecute is a helper method to define mock.On call +// - r admin.ListOrganizationUsersApiRequest +func (_e *OrganizationsApi_Expecter) ListOrganizationUsersExecute(r interface{}) *OrganizationsApi_ListOrganizationUsersExecute_Call { + return &OrganizationsApi_ListOrganizationUsersExecute_Call{Call: _e.mock.On("ListOrganizationUsersExecute", r)} +} + +func (_c *OrganizationsApi_ListOrganizationUsersExecute_Call) Run(run func(r admin.ListOrganizationUsersApiRequest)) *OrganizationsApi_ListOrganizationUsersExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOrganizationUsersApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsersExecute_Call) Return(_a0 *admin.PaginatedAppUser, _a1 *http.Response, _a2 error) *OrganizationsApi_ListOrganizationUsersExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsersExecute_Call) RunAndReturn(run func(admin.ListOrganizationUsersApiRequest) (*admin.PaginatedAppUser, *http.Response, error)) *OrganizationsApi_ListOrganizationUsersExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationUsersWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) ListOrganizationUsersWithParams(ctx context.Context, args *admin.ListOrganizationUsersApiParams) admin.ListOrganizationUsersApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationUsersWithParams") + } + + var r0 admin.ListOrganizationUsersApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationUsersApiParams) admin.ListOrganizationUsersApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOrganizationUsersApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationUsersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationUsersWithParams' +type OrganizationsApi_ListOrganizationUsersWithParams_Call struct { + *mock.Call +} + +// ListOrganizationUsersWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOrganizationUsersApiParams +func (_e *OrganizationsApi_Expecter) ListOrganizationUsersWithParams(ctx interface{}, args interface{}) *OrganizationsApi_ListOrganizationUsersWithParams_Call { + return &OrganizationsApi_ListOrganizationUsersWithParams_Call{Call: _e.mock.On("ListOrganizationUsersWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_ListOrganizationUsersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationUsersApiParams)) *OrganizationsApi_ListOrganizationUsersWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOrganizationUsersApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsersWithParams_Call) Return(_a0 admin.ListOrganizationUsersApiRequest) *OrganizationsApi_ListOrganizationUsersWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationUsersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationUsersApiParams) admin.ListOrganizationUsersApiRequest) *OrganizationsApi_ListOrganizationUsersWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizations provides a mock function with given fields: ctx +func (_m *OrganizationsApi) ListOrganizations(ctx context.Context) admin.ListOrganizationsApiRequest { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizations") + } + + var r0 admin.ListOrganizationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context) admin.ListOrganizationsApiRequest); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(admin.ListOrganizationsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizations' +type OrganizationsApi_ListOrganizations_Call struct { + *mock.Call +} + +// ListOrganizations is a helper method to define mock.On call +// - ctx context.Context +func (_e *OrganizationsApi_Expecter) ListOrganizations(ctx interface{}) *OrganizationsApi_ListOrganizations_Call { + return &OrganizationsApi_ListOrganizations_Call{Call: _e.mock.On("ListOrganizations", ctx)} +} + +func (_c *OrganizationsApi_ListOrganizations_Call) Run(run func(ctx context.Context)) *OrganizationsApi_ListOrganizations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizations_Call) Return(_a0 admin.ListOrganizationsApiRequest) *OrganizationsApi_ListOrganizations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizations_Call) RunAndReturn(run func(context.Context) admin.ListOrganizationsApiRequest) *OrganizationsApi_ListOrganizations_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationsExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) ListOrganizationsExecute(r admin.ListOrganizationsApiRequest) (*admin.PaginatedOrganization, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationsExecute") + } + + var r0 *admin.PaginatedOrganization + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListOrganizationsApiRequest) (*admin.PaginatedOrganization, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListOrganizationsApiRequest) *admin.PaginatedOrganization); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedOrganization) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListOrganizationsApiRequest) *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.ListOrganizationsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_ListOrganizationsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationsExecute' +type OrganizationsApi_ListOrganizationsExecute_Call struct { + *mock.Call +} + +// ListOrganizationsExecute is a helper method to define mock.On call +// - r admin.ListOrganizationsApiRequest +func (_e *OrganizationsApi_Expecter) ListOrganizationsExecute(r interface{}) *OrganizationsApi_ListOrganizationsExecute_Call { + return &OrganizationsApi_ListOrganizationsExecute_Call{Call: _e.mock.On("ListOrganizationsExecute", r)} +} + +func (_c *OrganizationsApi_ListOrganizationsExecute_Call) Run(run func(r admin.ListOrganizationsApiRequest)) *OrganizationsApi_ListOrganizationsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListOrganizationsApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationsExecute_Call) Return(_a0 *admin.PaginatedOrganization, _a1 *http.Response, _a2 error) *OrganizationsApi_ListOrganizationsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationsExecute_Call) RunAndReturn(run func(admin.ListOrganizationsApiRequest) (*admin.PaginatedOrganization, *http.Response, error)) *OrganizationsApi_ListOrganizationsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListOrganizationsWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) ListOrganizationsWithParams(ctx context.Context, args *admin.ListOrganizationsApiParams) admin.ListOrganizationsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListOrganizationsWithParams") + } + + var r0 admin.ListOrganizationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationsApiParams) admin.ListOrganizationsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListOrganizationsApiRequest) + } + + return r0 +} + +// OrganizationsApi_ListOrganizationsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationsWithParams' +type OrganizationsApi_ListOrganizationsWithParams_Call struct { + *mock.Call +} + +// ListOrganizationsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListOrganizationsApiParams +func (_e *OrganizationsApi_Expecter) ListOrganizationsWithParams(ctx interface{}, args interface{}) *OrganizationsApi_ListOrganizationsWithParams_Call { + return &OrganizationsApi_ListOrganizationsWithParams_Call{Call: _e.mock.On("ListOrganizationsWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_ListOrganizationsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationsApiParams)) *OrganizationsApi_ListOrganizationsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListOrganizationsApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationsWithParams_Call) Return(_a0 admin.ListOrganizationsApiRequest) *OrganizationsApi_ListOrganizationsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_ListOrganizationsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationsApiParams) admin.ListOrganizationsApiRequest) *OrganizationsApi_ListOrganizationsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// RemoveOrganizationUser provides a mock function with given fields: ctx, orgId, userId +func (_m *OrganizationsApi) RemoveOrganizationUser(ctx context.Context, orgId string, userId string) admin.RemoveOrganizationUserApiRequest { + ret := _m.Called(ctx, orgId, userId) + + if len(ret) == 0 { + panic("no return value specified for RemoveOrganizationUser") + } + + var r0 admin.RemoveOrganizationUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveOrganizationUserApiRequest); ok { + r0 = rf(ctx, orgId, userId) + } else { + r0 = ret.Get(0).(admin.RemoveOrganizationUserApiRequest) + } + + return r0 +} + +// OrganizationsApi_RemoveOrganizationUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOrganizationUser' +type OrganizationsApi_RemoveOrganizationUser_Call struct { + *mock.Call +} + +// RemoveOrganizationUser is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - userId string +func (_e *OrganizationsApi_Expecter) RemoveOrganizationUser(ctx interface{}, orgId interface{}, userId interface{}) *OrganizationsApi_RemoveOrganizationUser_Call { + return &OrganizationsApi_RemoveOrganizationUser_Call{Call: _e.mock.On("RemoveOrganizationUser", ctx, orgId, userId)} +} + +func (_c *OrganizationsApi_RemoveOrganizationUser_Call) Run(run func(ctx context.Context, orgId string, userId string)) *OrganizationsApi_RemoveOrganizationUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUser_Call) Return(_a0 admin.RemoveOrganizationUserApiRequest) *OrganizationsApi_RemoveOrganizationUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUser_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveOrganizationUserApiRequest) *OrganizationsApi_RemoveOrganizationUser_Call { + _c.Call.Return(run) + return _c +} + +// RemoveOrganizationUserExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) RemoveOrganizationUserExecute(r admin.RemoveOrganizationUserApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for RemoveOrganizationUserExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.RemoveOrganizationUserApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.RemoveOrganizationUserApiRequest) 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.RemoveOrganizationUserApiRequest) *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.RemoveOrganizationUserApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_RemoveOrganizationUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOrganizationUserExecute' +type OrganizationsApi_RemoveOrganizationUserExecute_Call struct { + *mock.Call +} + +// RemoveOrganizationUserExecute is a helper method to define mock.On call +// - r admin.RemoveOrganizationUserApiRequest +func (_e *OrganizationsApi_Expecter) RemoveOrganizationUserExecute(r interface{}) *OrganizationsApi_RemoveOrganizationUserExecute_Call { + return &OrganizationsApi_RemoveOrganizationUserExecute_Call{Call: _e.mock.On("RemoveOrganizationUserExecute", r)} +} + +func (_c *OrganizationsApi_RemoveOrganizationUserExecute_Call) Run(run func(r admin.RemoveOrganizationUserApiRequest)) *OrganizationsApi_RemoveOrganizationUserExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.RemoveOrganizationUserApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUserExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *OrganizationsApi_RemoveOrganizationUserExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUserExecute_Call) RunAndReturn(run func(admin.RemoveOrganizationUserApiRequest) (map[string]interface{}, *http.Response, error)) *OrganizationsApi_RemoveOrganizationUserExecute_Call { + _c.Call.Return(run) + return _c +} + +// RemoveOrganizationUserWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) RemoveOrganizationUserWithParams(ctx context.Context, args *admin.RemoveOrganizationUserApiParams) admin.RemoveOrganizationUserApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for RemoveOrganizationUserWithParams") + } + + var r0 admin.RemoveOrganizationUserApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveOrganizationUserApiParams) admin.RemoveOrganizationUserApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.RemoveOrganizationUserApiRequest) + } + + return r0 +} + +// OrganizationsApi_RemoveOrganizationUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOrganizationUserWithParams' +type OrganizationsApi_RemoveOrganizationUserWithParams_Call struct { + *mock.Call +} + +// RemoveOrganizationUserWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.RemoveOrganizationUserApiParams +func (_e *OrganizationsApi_Expecter) RemoveOrganizationUserWithParams(ctx interface{}, args interface{}) *OrganizationsApi_RemoveOrganizationUserWithParams_Call { + return &OrganizationsApi_RemoveOrganizationUserWithParams_Call{Call: _e.mock.On("RemoveOrganizationUserWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_RemoveOrganizationUserWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveOrganizationUserApiParams)) *OrganizationsApi_RemoveOrganizationUserWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.RemoveOrganizationUserApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUserWithParams_Call) Return(_a0 admin.RemoveOrganizationUserApiRequest) *OrganizationsApi_RemoveOrganizationUserWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_RemoveOrganizationUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveOrganizationUserApiParams) admin.RemoveOrganizationUserApiRequest) *OrganizationsApi_RemoveOrganizationUserWithParams_Call { + _c.Call.Return(run) + return _c +} + +// RenameOrganization provides a mock function with given fields: ctx, orgId, atlasOrganization +func (_m *OrganizationsApi) RenameOrganization(ctx context.Context, orgId string, atlasOrganization *admin.AtlasOrganization) admin.RenameOrganizationApiRequest { + ret := _m.Called(ctx, orgId, atlasOrganization) + + if len(ret) == 0 { + panic("no return value specified for RenameOrganization") + } + + var r0 admin.RenameOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.AtlasOrganization) admin.RenameOrganizationApiRequest); ok { + r0 = rf(ctx, orgId, atlasOrganization) + } else { + r0 = ret.Get(0).(admin.RenameOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_RenameOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameOrganization' +type OrganizationsApi_RenameOrganization_Call struct { + *mock.Call +} + +// RenameOrganization is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - atlasOrganization *admin.AtlasOrganization +func (_e *OrganizationsApi_Expecter) RenameOrganization(ctx interface{}, orgId interface{}, atlasOrganization interface{}) *OrganizationsApi_RenameOrganization_Call { + return &OrganizationsApi_RenameOrganization_Call{Call: _e.mock.On("RenameOrganization", ctx, orgId, atlasOrganization)} +} + +func (_c *OrganizationsApi_RenameOrganization_Call) Run(run func(ctx context.Context, orgId string, atlasOrganization *admin.AtlasOrganization)) *OrganizationsApi_RenameOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.AtlasOrganization)) + }) + return _c +} + +func (_c *OrganizationsApi_RenameOrganization_Call) Return(_a0 admin.RenameOrganizationApiRequest) *OrganizationsApi_RenameOrganization_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_RenameOrganization_Call) RunAndReturn(run func(context.Context, string, *admin.AtlasOrganization) admin.RenameOrganizationApiRequest) *OrganizationsApi_RenameOrganization_Call { + _c.Call.Return(run) + return _c +} + +// RenameOrganizationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) RenameOrganizationExecute(r admin.RenameOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for RenameOrganizationExecute") + } + + var r0 *admin.AtlasOrganization + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.RenameOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.RenameOrganizationApiRequest) *admin.AtlasOrganization); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.AtlasOrganization) + } + } + + if rf, ok := ret.Get(1).(func(admin.RenameOrganizationApiRequest) *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.RenameOrganizationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_RenameOrganizationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameOrganizationExecute' +type OrganizationsApi_RenameOrganizationExecute_Call struct { + *mock.Call +} + +// RenameOrganizationExecute is a helper method to define mock.On call +// - r admin.RenameOrganizationApiRequest +func (_e *OrganizationsApi_Expecter) RenameOrganizationExecute(r interface{}) *OrganizationsApi_RenameOrganizationExecute_Call { + return &OrganizationsApi_RenameOrganizationExecute_Call{Call: _e.mock.On("RenameOrganizationExecute", r)} +} + +func (_c *OrganizationsApi_RenameOrganizationExecute_Call) Run(run func(r admin.RenameOrganizationApiRequest)) *OrganizationsApi_RenameOrganizationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.RenameOrganizationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_RenameOrganizationExecute_Call) Return(_a0 *admin.AtlasOrganization, _a1 *http.Response, _a2 error) *OrganizationsApi_RenameOrganizationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_RenameOrganizationExecute_Call) RunAndReturn(run func(admin.RenameOrganizationApiRequest) (*admin.AtlasOrganization, *http.Response, error)) *OrganizationsApi_RenameOrganizationExecute_Call { + _c.Call.Return(run) + return _c +} + +// RenameOrganizationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) RenameOrganizationWithParams(ctx context.Context, args *admin.RenameOrganizationApiParams) admin.RenameOrganizationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for RenameOrganizationWithParams") + } + + var r0 admin.RenameOrganizationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.RenameOrganizationApiParams) admin.RenameOrganizationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.RenameOrganizationApiRequest) + } + + return r0 +} + +// OrganizationsApi_RenameOrganizationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameOrganizationWithParams' +type OrganizationsApi_RenameOrganizationWithParams_Call struct { + *mock.Call +} + +// RenameOrganizationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.RenameOrganizationApiParams +func (_e *OrganizationsApi_Expecter) RenameOrganizationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_RenameOrganizationWithParams_Call { + return &OrganizationsApi_RenameOrganizationWithParams_Call{Call: _e.mock.On("RenameOrganizationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_RenameOrganizationWithParams_Call) Run(run func(ctx context.Context, args *admin.RenameOrganizationApiParams)) *OrganizationsApi_RenameOrganizationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.RenameOrganizationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_RenameOrganizationWithParams_Call) Return(_a0 admin.RenameOrganizationApiRequest) *OrganizationsApi_RenameOrganizationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_RenameOrganizationWithParams_Call) RunAndReturn(run func(context.Context, *admin.RenameOrganizationApiParams) admin.RenameOrganizationApiRequest) *OrganizationsApi_RenameOrganizationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitation provides a mock function with given fields: ctx, orgId, organizationInvitationRequest +func (_m *OrganizationsApi) UpdateOrganizationInvitation(ctx context.Context, orgId string, organizationInvitationRequest *admin.OrganizationInvitationRequest) admin.UpdateOrganizationInvitationApiRequest { + ret := _m.Called(ctx, orgId, organizationInvitationRequest) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitation") + } + + var r0 admin.UpdateOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.OrganizationInvitationRequest) admin.UpdateOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, orgId, organizationInvitationRequest) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitation' +type OrganizationsApi_UpdateOrganizationInvitation_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitation is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - organizationInvitationRequest *admin.OrganizationInvitationRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitation(ctx interface{}, orgId interface{}, organizationInvitationRequest interface{}) *OrganizationsApi_UpdateOrganizationInvitation_Call { + return &OrganizationsApi_UpdateOrganizationInvitation_Call{Call: _e.mock.On("UpdateOrganizationInvitation", ctx, orgId, organizationInvitationRequest)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitation_Call) Run(run func(ctx context.Context, orgId string, organizationInvitationRequest *admin.OrganizationInvitationRequest)) *OrganizationsApi_UpdateOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.OrganizationInvitationRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitation_Call) Return(_a0 admin.UpdateOrganizationInvitationApiRequest) *OrganizationsApi_UpdateOrganizationInvitation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitation_Call) RunAndReturn(run func(context.Context, string, *admin.OrganizationInvitationRequest) admin.UpdateOrganizationInvitationApiRequest) *OrganizationsApi_UpdateOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitationById provides a mock function with given fields: ctx, orgId, invitationId, organizationInvitationUpdateRequest +func (_m *OrganizationsApi) UpdateOrganizationInvitationById(ctx context.Context, orgId string, invitationId string, organizationInvitationUpdateRequest *admin.OrganizationInvitationUpdateRequest) admin.UpdateOrganizationInvitationByIdApiRequest { + ret := _m.Called(ctx, orgId, invitationId, organizationInvitationUpdateRequest) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitationById") + } + + var r0 admin.UpdateOrganizationInvitationByIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.OrganizationInvitationUpdateRequest) admin.UpdateOrganizationInvitationByIdApiRequest); ok { + r0 = rf(ctx, orgId, invitationId, organizationInvitationUpdateRequest) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationInvitationByIdApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationInvitationById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitationById' +type OrganizationsApi_UpdateOrganizationInvitationById_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitationById is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - invitationId string +// - organizationInvitationUpdateRequest *admin.OrganizationInvitationUpdateRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitationById(ctx interface{}, orgId interface{}, invitationId interface{}, organizationInvitationUpdateRequest interface{}) *OrganizationsApi_UpdateOrganizationInvitationById_Call { + return &OrganizationsApi_UpdateOrganizationInvitationById_Call{Call: _e.mock.On("UpdateOrganizationInvitationById", ctx, orgId, invitationId, organizationInvitationUpdateRequest)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationById_Call) Run(run func(ctx context.Context, orgId string, invitationId string, organizationInvitationUpdateRequest *admin.OrganizationInvitationUpdateRequest)) *OrganizationsApi_UpdateOrganizationInvitationById_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.OrganizationInvitationUpdateRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationById_Call) Return(_a0 admin.UpdateOrganizationInvitationByIdApiRequest) *OrganizationsApi_UpdateOrganizationInvitationById_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationById_Call) RunAndReturn(run func(context.Context, string, string, *admin.OrganizationInvitationUpdateRequest) admin.UpdateOrganizationInvitationByIdApiRequest) *OrganizationsApi_UpdateOrganizationInvitationById_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitationByIdExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) UpdateOrganizationInvitationByIdExecute(r admin.UpdateOrganizationInvitationByIdApiRequest) (*admin.OrganizationInvitation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitationByIdExecute") + } + + var r0 *admin.OrganizationInvitation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationInvitationByIdApiRequest) (*admin.OrganizationInvitation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationInvitationByIdApiRequest) *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.UpdateOrganizationInvitationByIdApiRequest) *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.UpdateOrganizationInvitationByIdApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitationByIdExecute' +type OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitationByIdExecute is a helper method to define mock.On call +// - r admin.UpdateOrganizationInvitationByIdApiRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitationByIdExecute(r interface{}) *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call { + return &OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call{Call: _e.mock.On("UpdateOrganizationInvitationByIdExecute", r)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call) Run(run func(r admin.UpdateOrganizationInvitationByIdApiRequest)) *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateOrganizationInvitationByIdApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call) Return(_a0 *admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call) RunAndReturn(run func(admin.UpdateOrganizationInvitationByIdApiRequest) (*admin.OrganizationInvitation, *http.Response, error)) *OrganizationsApi_UpdateOrganizationInvitationByIdExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitationByIdWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) UpdateOrganizationInvitationByIdWithParams(ctx context.Context, args *admin.UpdateOrganizationInvitationByIdApiParams) admin.UpdateOrganizationInvitationByIdApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitationByIdWithParams") + } + + var r0 admin.UpdateOrganizationInvitationByIdApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateOrganizationInvitationByIdApiParams) admin.UpdateOrganizationInvitationByIdApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationInvitationByIdApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitationByIdWithParams' +type OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitationByIdWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateOrganizationInvitationByIdApiParams +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitationByIdWithParams(ctx interface{}, args interface{}) *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call { + return &OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call{Call: _e.mock.On("UpdateOrganizationInvitationByIdWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateOrganizationInvitationByIdApiParams)) *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateOrganizationInvitationByIdApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call) Return(_a0 admin.UpdateOrganizationInvitationByIdApiRequest) *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOrganizationInvitationByIdApiParams) admin.UpdateOrganizationInvitationByIdApiRequest) *OrganizationsApi_UpdateOrganizationInvitationByIdWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitationExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) UpdateOrganizationInvitationExecute(r admin.UpdateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitationExecute") + } + + var r0 *admin.OrganizationInvitation + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationInvitationApiRequest) *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.UpdateOrganizationInvitationApiRequest) *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.UpdateOrganizationInvitationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_UpdateOrganizationInvitationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitationExecute' +type OrganizationsApi_UpdateOrganizationInvitationExecute_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitationExecute is a helper method to define mock.On call +// - r admin.UpdateOrganizationInvitationApiRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitationExecute(r interface{}) *OrganizationsApi_UpdateOrganizationInvitationExecute_Call { + return &OrganizationsApi_UpdateOrganizationInvitationExecute_Call{Call: _e.mock.On("UpdateOrganizationInvitationExecute", r)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationExecute_Call) Run(run func(r admin.UpdateOrganizationInvitationApiRequest)) *OrganizationsApi_UpdateOrganizationInvitationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateOrganizationInvitationApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationExecute_Call) Return(_a0 *admin.OrganizationInvitation, _a1 *http.Response, _a2 error) *OrganizationsApi_UpdateOrganizationInvitationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationExecute_Call) RunAndReturn(run func(admin.UpdateOrganizationInvitationApiRequest) (*admin.OrganizationInvitation, *http.Response, error)) *OrganizationsApi_UpdateOrganizationInvitationExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationInvitationWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) UpdateOrganizationInvitationWithParams(ctx context.Context, args *admin.UpdateOrganizationInvitationApiParams) admin.UpdateOrganizationInvitationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationInvitationWithParams") + } + + var r0 admin.UpdateOrganizationInvitationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateOrganizationInvitationApiParams) admin.UpdateOrganizationInvitationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationInvitationApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationInvitationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationInvitationWithParams' +type OrganizationsApi_UpdateOrganizationInvitationWithParams_Call struct { + *mock.Call +} + +// UpdateOrganizationInvitationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateOrganizationInvitationApiParams +func (_e *OrganizationsApi_Expecter) UpdateOrganizationInvitationWithParams(ctx interface{}, args interface{}) *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call { + return &OrganizationsApi_UpdateOrganizationInvitationWithParams_Call{Call: _e.mock.On("UpdateOrganizationInvitationWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateOrganizationInvitationApiParams)) *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateOrganizationInvitationApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call) Return(_a0 admin.UpdateOrganizationInvitationApiRequest) *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOrganizationInvitationApiParams) admin.UpdateOrganizationInvitationApiRequest) *OrganizationsApi_UpdateOrganizationInvitationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationRoles provides a mock function with given fields: ctx, orgId, userId, updateOrgRolesForUser +func (_m *OrganizationsApi) UpdateOrganizationRoles(ctx context.Context, orgId string, userId string, updateOrgRolesForUser *admin.UpdateOrgRolesForUser) admin.UpdateOrganizationRolesApiRequest { + ret := _m.Called(ctx, orgId, userId, updateOrgRolesForUser) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationRoles") + } + + var r0 admin.UpdateOrganizationRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UpdateOrgRolesForUser) admin.UpdateOrganizationRolesApiRequest); ok { + r0 = rf(ctx, orgId, userId, updateOrgRolesForUser) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationRolesApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationRoles' +type OrganizationsApi_UpdateOrganizationRoles_Call struct { + *mock.Call +} + +// UpdateOrganizationRoles is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - userId string +// - updateOrgRolesForUser *admin.UpdateOrgRolesForUser +func (_e *OrganizationsApi_Expecter) UpdateOrganizationRoles(ctx interface{}, orgId interface{}, userId interface{}, updateOrgRolesForUser interface{}) *OrganizationsApi_UpdateOrganizationRoles_Call { + return &OrganizationsApi_UpdateOrganizationRoles_Call{Call: _e.mock.On("UpdateOrganizationRoles", ctx, orgId, userId, updateOrgRolesForUser)} +} + +func (_c *OrganizationsApi_UpdateOrganizationRoles_Call) Run(run func(ctx context.Context, orgId string, userId string, updateOrgRolesForUser *admin.UpdateOrgRolesForUser)) *OrganizationsApi_UpdateOrganizationRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateOrgRolesForUser)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRoles_Call) Return(_a0 admin.UpdateOrganizationRolesApiRequest) *OrganizationsApi_UpdateOrganizationRoles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateOrgRolesForUser) admin.UpdateOrganizationRolesApiRequest) *OrganizationsApi_UpdateOrganizationRoles_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationRolesExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) UpdateOrganizationRolesExecute(r admin.UpdateOrganizationRolesApiRequest) (*admin.UpdateOrgRolesForUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationRolesExecute") + } + + var r0 *admin.UpdateOrgRolesForUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationRolesApiRequest) (*admin.UpdateOrgRolesForUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationRolesApiRequest) *admin.UpdateOrgRolesForUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UpdateOrgRolesForUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateOrganizationRolesApiRequest) *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.UpdateOrganizationRolesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_UpdateOrganizationRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationRolesExecute' +type OrganizationsApi_UpdateOrganizationRolesExecute_Call struct { + *mock.Call +} + +// UpdateOrganizationRolesExecute is a helper method to define mock.On call +// - r admin.UpdateOrganizationRolesApiRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationRolesExecute(r interface{}) *OrganizationsApi_UpdateOrganizationRolesExecute_Call { + return &OrganizationsApi_UpdateOrganizationRolesExecute_Call{Call: _e.mock.On("UpdateOrganizationRolesExecute", r)} +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesExecute_Call) Run(run func(r admin.UpdateOrganizationRolesApiRequest)) *OrganizationsApi_UpdateOrganizationRolesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateOrganizationRolesApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesExecute_Call) Return(_a0 *admin.UpdateOrgRolesForUser, _a1 *http.Response, _a2 error) *OrganizationsApi_UpdateOrganizationRolesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesExecute_Call) RunAndReturn(run func(admin.UpdateOrganizationRolesApiRequest) (*admin.UpdateOrgRolesForUser, *http.Response, error)) *OrganizationsApi_UpdateOrganizationRolesExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationRolesWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) UpdateOrganizationRolesWithParams(ctx context.Context, args *admin.UpdateOrganizationRolesApiParams) admin.UpdateOrganizationRolesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationRolesWithParams") + } + + var r0 admin.UpdateOrganizationRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateOrganizationRolesApiParams) admin.UpdateOrganizationRolesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationRolesApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationRolesWithParams' +type OrganizationsApi_UpdateOrganizationRolesWithParams_Call struct { + *mock.Call +} + +// UpdateOrganizationRolesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateOrganizationRolesApiParams +func (_e *OrganizationsApi_Expecter) UpdateOrganizationRolesWithParams(ctx interface{}, args interface{}) *OrganizationsApi_UpdateOrganizationRolesWithParams_Call { + return &OrganizationsApi_UpdateOrganizationRolesWithParams_Call{Call: _e.mock.On("UpdateOrganizationRolesWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateOrganizationRolesApiParams)) *OrganizationsApi_UpdateOrganizationRolesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateOrganizationRolesApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesWithParams_Call) Return(_a0 admin.UpdateOrganizationRolesApiRequest) *OrganizationsApi_UpdateOrganizationRolesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOrganizationRolesApiParams) admin.UpdateOrganizationRolesApiRequest) *OrganizationsApi_UpdateOrganizationRolesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationSettings provides a mock function with given fields: ctx, orgId, organizationSettings +func (_m *OrganizationsApi) UpdateOrganizationSettings(ctx context.Context, orgId string, organizationSettings *admin.OrganizationSettings) admin.UpdateOrganizationSettingsApiRequest { + ret := _m.Called(ctx, orgId, organizationSettings) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationSettings") + } + + var r0 admin.UpdateOrganizationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.OrganizationSettings) admin.UpdateOrganizationSettingsApiRequest); ok { + r0 = rf(ctx, orgId, organizationSettings) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationSettingsApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationSettings' +type OrganizationsApi_UpdateOrganizationSettings_Call struct { + *mock.Call +} + +// UpdateOrganizationSettings is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - organizationSettings *admin.OrganizationSettings +func (_e *OrganizationsApi_Expecter) UpdateOrganizationSettings(ctx interface{}, orgId interface{}, organizationSettings interface{}) *OrganizationsApi_UpdateOrganizationSettings_Call { + return &OrganizationsApi_UpdateOrganizationSettings_Call{Call: _e.mock.On("UpdateOrganizationSettings", ctx, orgId, organizationSettings)} +} + +func (_c *OrganizationsApi_UpdateOrganizationSettings_Call) Run(run func(ctx context.Context, orgId string, organizationSettings *admin.OrganizationSettings)) *OrganizationsApi_UpdateOrganizationSettings_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.OrganizationSettings)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettings_Call) Return(_a0 admin.UpdateOrganizationSettingsApiRequest) *OrganizationsApi_UpdateOrganizationSettings_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettings_Call) RunAndReturn(run func(context.Context, string, *admin.OrganizationSettings) admin.UpdateOrganizationSettingsApiRequest) *OrganizationsApi_UpdateOrganizationSettings_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationSettingsExecute provides a mock function with given fields: r +func (_m *OrganizationsApi) UpdateOrganizationSettingsExecute(r admin.UpdateOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationSettingsExecute") + } + + var r0 *admin.OrganizationSettings + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateOrganizationSettingsApiRequest) *admin.OrganizationSettings); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.OrganizationSettings) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateOrganizationSettingsApiRequest) *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.UpdateOrganizationSettingsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// OrganizationsApi_UpdateOrganizationSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationSettingsExecute' +type OrganizationsApi_UpdateOrganizationSettingsExecute_Call struct { + *mock.Call +} + +// UpdateOrganizationSettingsExecute is a helper method to define mock.On call +// - r admin.UpdateOrganizationSettingsApiRequest +func (_e *OrganizationsApi_Expecter) UpdateOrganizationSettingsExecute(r interface{}) *OrganizationsApi_UpdateOrganizationSettingsExecute_Call { + return &OrganizationsApi_UpdateOrganizationSettingsExecute_Call{Call: _e.mock.On("UpdateOrganizationSettingsExecute", r)} +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsExecute_Call) Run(run func(r admin.UpdateOrganizationSettingsApiRequest)) *OrganizationsApi_UpdateOrganizationSettingsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateOrganizationSettingsApiRequest)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsExecute_Call) Return(_a0 *admin.OrganizationSettings, _a1 *http.Response, _a2 error) *OrganizationsApi_UpdateOrganizationSettingsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsExecute_Call) RunAndReturn(run func(admin.UpdateOrganizationSettingsApiRequest) (*admin.OrganizationSettings, *http.Response, error)) *OrganizationsApi_UpdateOrganizationSettingsExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOrganizationSettingsWithParams provides a mock function with given fields: ctx, args +func (_m *OrganizationsApi) UpdateOrganizationSettingsWithParams(ctx context.Context, args *admin.UpdateOrganizationSettingsApiParams) admin.UpdateOrganizationSettingsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateOrganizationSettingsWithParams") + } + + var r0 admin.UpdateOrganizationSettingsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateOrganizationSettingsApiParams) admin.UpdateOrganizationSettingsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateOrganizationSettingsApiRequest) + } + + return r0 +} + +// OrganizationsApi_UpdateOrganizationSettingsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOrganizationSettingsWithParams' +type OrganizationsApi_UpdateOrganizationSettingsWithParams_Call struct { + *mock.Call +} + +// UpdateOrganizationSettingsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateOrganizationSettingsApiParams +func (_e *OrganizationsApi_Expecter) UpdateOrganizationSettingsWithParams(ctx interface{}, args interface{}) *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call { + return &OrganizationsApi_UpdateOrganizationSettingsWithParams_Call{Call: _e.mock.On("UpdateOrganizationSettingsWithParams", ctx, args)} +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateOrganizationSettingsApiParams)) *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateOrganizationSettingsApiParams)) + }) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call) Return(_a0 admin.UpdateOrganizationSettingsApiRequest) *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOrganizationSettingsApiParams) admin.UpdateOrganizationSettingsApiRequest) *OrganizationsApi_UpdateOrganizationSettingsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewOrganizationsApi creates a new instance of OrganizationsApi. 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 NewOrganizationsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *OrganizationsApi { + mock := &OrganizationsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/performance_advisor_api.go b/mockadmin/performance_advisor_api.go new file mode 100644 index 000000000..93d3711e4 --- /dev/null +++ b/mockadmin/performance_advisor_api.go @@ -0,0 +1,1152 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// PerformanceAdvisorApi is an autogenerated mock type for the PerformanceAdvisorApi type +type PerformanceAdvisorApi struct { + mock.Mock +} + +type PerformanceAdvisorApi_Expecter struct { + mock *mock.Mock +} + +func (_m *PerformanceAdvisorApi) EXPECT() *PerformanceAdvisorApi_Expecter { + return &PerformanceAdvisorApi_Expecter{mock: &_m.Mock} +} + +// DisableSlowOperationThresholding provides a mock function with given fields: ctx, groupId +func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholding(ctx context.Context, groupId string) admin.DisableSlowOperationThresholdingApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for DisableSlowOperationThresholding") + } + + var r0 admin.DisableSlowOperationThresholdingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DisableSlowOperationThresholdingApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.DisableSlowOperationThresholdingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_DisableSlowOperationThresholding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholding' +type PerformanceAdvisorApi_DisableSlowOperationThresholding_Call struct { + *mock.Call +} + +// DisableSlowOperationThresholding is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholding(ctx interface{}, groupId interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call { + return &PerformanceAdvisorApi_DisableSlowOperationThresholding_Call{Call: _e.mock.On("DisableSlowOperationThresholding", ctx, groupId)} +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) Run(run func(ctx context.Context, groupId string)) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) Return(_a0 admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call) RunAndReturn(run func(context.Context, string) admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholding_Call { + _c.Call.Return(run) + return _c +} + +// DisableSlowOperationThresholdingExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholdingExecute(r admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DisableSlowOperationThresholdingExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DisableSlowOperationThresholdingApiRequest) *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.DisableSlowOperationThresholdingApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholdingExecute' +type PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call struct { + *mock.Call +} + +// DisableSlowOperationThresholdingExecute is a helper method to define mock.On call +// - r admin.DisableSlowOperationThresholdingApiRequest +func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholdingExecute(r interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call { + return &PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call{Call: _e.mock.On("DisableSlowOperationThresholdingExecute", r)} +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) Run(run func(r admin.DisableSlowOperationThresholdingApiRequest)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DisableSlowOperationThresholdingApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) Return(_a0 *http.Response, _a1 error) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call) RunAndReturn(run func(admin.DisableSlowOperationThresholdingApiRequest) (*http.Response, error)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingExecute_Call { + _c.Call.Return(run) + return _c +} + +// DisableSlowOperationThresholdingWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) DisableSlowOperationThresholdingWithParams(ctx context.Context, args *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DisableSlowOperationThresholdingWithParams") + } + + var r0 admin.DisableSlowOperationThresholdingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DisableSlowOperationThresholdingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSlowOperationThresholdingWithParams' +type PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call struct { + *mock.Call +} + +// DisableSlowOperationThresholdingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DisableSlowOperationThresholdingApiParams +func (_e *PerformanceAdvisorApi_Expecter) DisableSlowOperationThresholdingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call { + return &PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call{Call: _e.mock.On("DisableSlowOperationThresholdingWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) Run(run func(ctx context.Context, args *admin.DisableSlowOperationThresholdingApiParams)) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DisableSlowOperationThresholdingApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) Return(_a0 admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call) RunAndReturn(run func(context.Context, *admin.DisableSlowOperationThresholdingApiParams) admin.DisableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_DisableSlowOperationThresholdingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// EnableSlowOperationThresholding provides a mock function with given fields: ctx, groupId +func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholding(ctx context.Context, groupId string) admin.EnableSlowOperationThresholdingApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for EnableSlowOperationThresholding") + } + + var r0 admin.EnableSlowOperationThresholdingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.EnableSlowOperationThresholdingApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.EnableSlowOperationThresholdingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_EnableSlowOperationThresholding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholding' +type PerformanceAdvisorApi_EnableSlowOperationThresholding_Call struct { + *mock.Call +} + +// EnableSlowOperationThresholding is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholding(ctx interface{}, groupId interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call { + return &PerformanceAdvisorApi_EnableSlowOperationThresholding_Call{Call: _e.mock.On("EnableSlowOperationThresholding", ctx, groupId)} +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) Run(run func(ctx context.Context, groupId string)) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) Return(_a0 admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call) RunAndReturn(run func(context.Context, string) admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholding_Call { + _c.Call.Return(run) + return _c +} + +// EnableSlowOperationThresholdingExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholdingExecute(r admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for EnableSlowOperationThresholdingExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.EnableSlowOperationThresholdingApiRequest) *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.EnableSlowOperationThresholdingApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholdingExecute' +type PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call struct { + *mock.Call +} + +// EnableSlowOperationThresholdingExecute is a helper method to define mock.On call +// - r admin.EnableSlowOperationThresholdingApiRequest +func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholdingExecute(r interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call { + return &PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call{Call: _e.mock.On("EnableSlowOperationThresholdingExecute", r)} +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) Run(run func(r admin.EnableSlowOperationThresholdingApiRequest)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.EnableSlowOperationThresholdingApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) Return(_a0 *http.Response, _a1 error) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call) RunAndReturn(run func(admin.EnableSlowOperationThresholdingApiRequest) (*http.Response, error)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingExecute_Call { + _c.Call.Return(run) + return _c +} + +// EnableSlowOperationThresholdingWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) EnableSlowOperationThresholdingWithParams(ctx context.Context, args *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for EnableSlowOperationThresholdingWithParams") + } + + var r0 admin.EnableSlowOperationThresholdingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.EnableSlowOperationThresholdingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSlowOperationThresholdingWithParams' +type PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call struct { + *mock.Call +} + +// EnableSlowOperationThresholdingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.EnableSlowOperationThresholdingApiParams +func (_e *PerformanceAdvisorApi_Expecter) EnableSlowOperationThresholdingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call { + return &PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call{Call: _e.mock.On("EnableSlowOperationThresholdingWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) Run(run func(ctx context.Context, args *admin.EnableSlowOperationThresholdingApiParams)) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.EnableSlowOperationThresholdingApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) Return(_a0 admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call) RunAndReturn(run func(context.Context, *admin.EnableSlowOperationThresholdingApiParams) admin.EnableSlowOperationThresholdingApiRequest) *PerformanceAdvisorApi_EnableSlowOperationThresholdingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessAutoIndexing provides a mock function with given fields: ctx, groupId, clusterName +func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexing(ctx context.Context, groupId string, clusterName string) admin.GetServerlessAutoIndexingApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessAutoIndexing") + } + + var r0 admin.GetServerlessAutoIndexingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetServerlessAutoIndexingApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.GetServerlessAutoIndexingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_GetServerlessAutoIndexing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexing' +type PerformanceAdvisorApi_GetServerlessAutoIndexing_Call struct { + *mock.Call +} + +// GetServerlessAutoIndexing is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexing(ctx interface{}, groupId interface{}, clusterName interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call { + return &PerformanceAdvisorApi_GetServerlessAutoIndexing_Call{Call: _e.mock.On("GetServerlessAutoIndexing", ctx, groupId, clusterName)} +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) Return(_a0 admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call) RunAndReturn(run func(context.Context, string, string) admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexing_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessAutoIndexingExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexingExecute(r admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessAutoIndexingExecute") + } + + var r0 bool + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetServerlessAutoIndexingApiRequest) bool); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(admin.GetServerlessAutoIndexingApiRequest) *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.GetServerlessAutoIndexingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexingExecute' +type PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call struct { + *mock.Call +} + +// GetServerlessAutoIndexingExecute is a helper method to define mock.On call +// - r admin.GetServerlessAutoIndexingApiRequest +func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexingExecute(r interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call { + return &PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call{Call: _e.mock.On("GetServerlessAutoIndexingExecute", r)} +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) Run(run func(r admin.GetServerlessAutoIndexingApiRequest)) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetServerlessAutoIndexingApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) Return(_a0 bool, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call) RunAndReturn(run func(admin.GetServerlessAutoIndexingApiRequest) (bool, *http.Response, error)) *PerformanceAdvisorApi_GetServerlessAutoIndexingExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessAutoIndexingWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) GetServerlessAutoIndexingWithParams(ctx context.Context, args *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessAutoIndexingWithParams") + } + + var r0 admin.GetServerlessAutoIndexingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetServerlessAutoIndexingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessAutoIndexingWithParams' +type PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call struct { + *mock.Call +} + +// GetServerlessAutoIndexingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetServerlessAutoIndexingApiParams +func (_e *PerformanceAdvisorApi_Expecter) GetServerlessAutoIndexingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call { + return &PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call{Call: _e.mock.On("GetServerlessAutoIndexingWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessAutoIndexingApiParams)) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetServerlessAutoIndexingApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) Return(_a0 admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessAutoIndexingApiParams) admin.GetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_GetServerlessAutoIndexingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueries provides a mock function with given fields: ctx, groupId, processId +func (_m *PerformanceAdvisorApi) ListSlowQueries(ctx context.Context, groupId string, processId string) admin.ListSlowQueriesApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueries") + } + + var r0 admin.ListSlowQueriesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSlowQueriesApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListSlowQueriesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSlowQueries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueries' +type PerformanceAdvisorApi_ListSlowQueries_Call struct { + *mock.Call +} + +// ListSlowQueries is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueries(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSlowQueries_Call { + return &PerformanceAdvisorApi_ListSlowQueries_Call{Call: _e.mock.On("ListSlowQueries", ctx, groupId, processId)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSlowQueries_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) Return(_a0 admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueries_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueries_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueries_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueriesExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) ListSlowQueriesExecute(r admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueriesExecute") + } + + var r0 *admin.PerformanceAdvisorSlowQueryList + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSlowQueriesApiRequest) *admin.PerformanceAdvisorSlowQueryList); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PerformanceAdvisorSlowQueryList) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSlowQueriesApiRequest) *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.ListSlowQueriesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PerformanceAdvisorApi_ListSlowQueriesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueriesExecute' +type PerformanceAdvisorApi_ListSlowQueriesExecute_Call struct { + *mock.Call +} + +// ListSlowQueriesExecute is a helper method to define mock.On call +// - r admin.ListSlowQueriesApiRequest +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueriesExecute(r interface{}) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call { + return &PerformanceAdvisorApi_ListSlowQueriesExecute_Call{Call: _e.mock.On("ListSlowQueriesExecute", r)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) Run(run func(r admin.ListSlowQueriesApiRequest)) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSlowQueriesApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) Return(_a0 *admin.PerformanceAdvisorSlowQueryList, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesExecute_Call) RunAndReturn(run func(admin.ListSlowQueriesApiRequest) (*admin.PerformanceAdvisorSlowQueryList, *http.Response, error)) *PerformanceAdvisorApi_ListSlowQueriesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueriesWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) ListSlowQueriesWithParams(ctx context.Context, args *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueriesWithParams") + } + + var r0 admin.ListSlowQueriesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSlowQueriesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSlowQueriesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueriesWithParams' +type PerformanceAdvisorApi_ListSlowQueriesWithParams_Call struct { + *mock.Call +} + +// ListSlowQueriesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSlowQueriesApiParams +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueriesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call { + return &PerformanceAdvisorApi_ListSlowQueriesWithParams_Call{Call: _e.mock.On("ListSlowQueriesWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSlowQueriesApiParams)) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSlowQueriesApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) Return(_a0 admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSlowQueriesApiParams) admin.ListSlowQueriesApiRequest) *PerformanceAdvisorApi_ListSlowQueriesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueryNamespaces provides a mock function with given fields: ctx, groupId, processId +func (_m *PerformanceAdvisorApi) ListSlowQueryNamespaces(ctx context.Context, groupId string, processId string) admin.ListSlowQueryNamespacesApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueryNamespaces") + } + + var r0 admin.ListSlowQueryNamespacesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSlowQueryNamespacesApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListSlowQueryNamespacesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSlowQueryNamespaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespaces' +type PerformanceAdvisorApi_ListSlowQueryNamespaces_Call struct { + *mock.Call +} + +// ListSlowQueryNamespaces is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespaces(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call { + return &PerformanceAdvisorApi_ListSlowQueryNamespaces_Call{Call: _e.mock.On("ListSlowQueryNamespaces", ctx, groupId, processId)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) Return(_a0 admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespaces_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueryNamespacesExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) ListSlowQueryNamespacesExecute(r admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueryNamespacesExecute") + } + + var r0 *admin.Namespaces + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSlowQueryNamespacesApiRequest) *admin.Namespaces); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.Namespaces) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSlowQueryNamespacesApiRequest) *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.ListSlowQueryNamespacesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespacesExecute' +type PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call struct { + *mock.Call +} + +// ListSlowQueryNamespacesExecute is a helper method to define mock.On call +// - r admin.ListSlowQueryNamespacesApiRequest +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespacesExecute(r interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call { + return &PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call{Call: _e.mock.On("ListSlowQueryNamespacesExecute", r)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) Run(run func(r admin.ListSlowQueryNamespacesApiRequest)) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSlowQueryNamespacesApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) Return(_a0 *admin.Namespaces, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call) RunAndReturn(run func(admin.ListSlowQueryNamespacesApiRequest) (*admin.Namespaces, *http.Response, error)) *PerformanceAdvisorApi_ListSlowQueryNamespacesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSlowQueryNamespacesWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) ListSlowQueryNamespacesWithParams(ctx context.Context, args *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSlowQueryNamespacesWithParams") + } + + var r0 admin.ListSlowQueryNamespacesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSlowQueryNamespacesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSlowQueryNamespacesWithParams' +type PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call struct { + *mock.Call +} + +// ListSlowQueryNamespacesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSlowQueryNamespacesApiParams +func (_e *PerformanceAdvisorApi_Expecter) ListSlowQueryNamespacesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call { + return &PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call{Call: _e.mock.On("ListSlowQueryNamespacesWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSlowQueryNamespacesApiParams)) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSlowQueryNamespacesApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) Return(_a0 admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSlowQueryNamespacesApiParams) admin.ListSlowQueryNamespacesApiRequest) *PerformanceAdvisorApi_ListSlowQueryNamespacesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSuggestedIndexes provides a mock function with given fields: ctx, groupId, processId +func (_m *PerformanceAdvisorApi) ListSuggestedIndexes(ctx context.Context, groupId string, processId string) admin.ListSuggestedIndexesApiRequest { + ret := _m.Called(ctx, groupId, processId) + + if len(ret) == 0 { + panic("no return value specified for ListSuggestedIndexes") + } + + var r0 admin.ListSuggestedIndexesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSuggestedIndexesApiRequest); ok { + r0 = rf(ctx, groupId, processId) + } else { + r0 = ret.Get(0).(admin.ListSuggestedIndexesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSuggestedIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexes' +type PerformanceAdvisorApi_ListSuggestedIndexes_Call struct { + *mock.Call +} + +// ListSuggestedIndexes is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - processId string +func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexes(ctx interface{}, groupId interface{}, processId interface{}) *PerformanceAdvisorApi_ListSuggestedIndexes_Call { + return &PerformanceAdvisorApi_ListSuggestedIndexes_Call{Call: _e.mock.On("ListSuggestedIndexes", ctx, groupId, processId)} +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) Run(run func(ctx context.Context, groupId string, processId string)) *PerformanceAdvisorApi_ListSuggestedIndexes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) Return(_a0 admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexes_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexes_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexes_Call { + _c.Call.Return(run) + return _c +} + +// ListSuggestedIndexesExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) ListSuggestedIndexesExecute(r admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSuggestedIndexesExecute") + } + + var r0 *admin.PerformanceAdvisorResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSuggestedIndexesApiRequest) *admin.PerformanceAdvisorResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PerformanceAdvisorResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSuggestedIndexesApiRequest) *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.ListSuggestedIndexesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexesExecute' +type PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call struct { + *mock.Call +} + +// ListSuggestedIndexesExecute is a helper method to define mock.On call +// - r admin.ListSuggestedIndexesApiRequest +func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexesExecute(r interface{}) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call { + return &PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call{Call: _e.mock.On("ListSuggestedIndexesExecute", r)} +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) Run(run func(r admin.ListSuggestedIndexesApiRequest)) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSuggestedIndexesApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) Return(_a0 *admin.PerformanceAdvisorResponse, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call) RunAndReturn(run func(admin.ListSuggestedIndexesApiRequest) (*admin.PerformanceAdvisorResponse, *http.Response, error)) *PerformanceAdvisorApi_ListSuggestedIndexesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSuggestedIndexesWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) ListSuggestedIndexesWithParams(ctx context.Context, args *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSuggestedIndexesWithParams") + } + + var r0 admin.ListSuggestedIndexesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSuggestedIndexesApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSuggestedIndexesWithParams' +type PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call struct { + *mock.Call +} + +// ListSuggestedIndexesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSuggestedIndexesApiParams +func (_e *PerformanceAdvisorApi_Expecter) ListSuggestedIndexesWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call { + return &PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call{Call: _e.mock.On("ListSuggestedIndexesWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSuggestedIndexesApiParams)) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSuggestedIndexesApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) Return(_a0 admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSuggestedIndexesApiParams) admin.ListSuggestedIndexesApiRequest) *PerformanceAdvisorApi_ListSuggestedIndexesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// SetServerlessAutoIndexing provides a mock function with given fields: ctx, groupId, clusterName +func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexing(ctx context.Context, groupId string, clusterName string) admin.SetServerlessAutoIndexingApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for SetServerlessAutoIndexing") + } + + var r0 admin.SetServerlessAutoIndexingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.SetServerlessAutoIndexingApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.SetServerlessAutoIndexingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_SetServerlessAutoIndexing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexing' +type PerformanceAdvisorApi_SetServerlessAutoIndexing_Call struct { + *mock.Call +} + +// SetServerlessAutoIndexing is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexing(ctx interface{}, groupId interface{}, clusterName interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call { + return &PerformanceAdvisorApi_SetServerlessAutoIndexing_Call{Call: _e.mock.On("SetServerlessAutoIndexing", ctx, groupId, clusterName)} +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) Return(_a0 admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call) RunAndReturn(run func(context.Context, string, string) admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexing_Call { + _c.Call.Return(run) + return _c +} + +// SetServerlessAutoIndexingExecute provides a mock function with given fields: r +func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexingExecute(r admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for SetServerlessAutoIndexingExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.SetServerlessAutoIndexingApiRequest) 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.SetServerlessAutoIndexingApiRequest) *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.SetServerlessAutoIndexingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexingExecute' +type PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call struct { + *mock.Call +} + +// SetServerlessAutoIndexingExecute is a helper method to define mock.On call +// - r admin.SetServerlessAutoIndexingApiRequest +func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexingExecute(r interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call { + return &PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call{Call: _e.mock.On("SetServerlessAutoIndexingExecute", r)} +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) Run(run func(r admin.SetServerlessAutoIndexingApiRequest)) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.SetServerlessAutoIndexingApiRequest)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call) RunAndReturn(run func(admin.SetServerlessAutoIndexingApiRequest) (map[string]interface{}, *http.Response, error)) *PerformanceAdvisorApi_SetServerlessAutoIndexingExecute_Call { + _c.Call.Return(run) + return _c +} + +// SetServerlessAutoIndexingWithParams provides a mock function with given fields: ctx, args +func (_m *PerformanceAdvisorApi) SetServerlessAutoIndexingWithParams(ctx context.Context, args *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for SetServerlessAutoIndexingWithParams") + } + + var r0 admin.SetServerlessAutoIndexingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.SetServerlessAutoIndexingApiRequest) + } + + return r0 +} + +// PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServerlessAutoIndexingWithParams' +type PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call struct { + *mock.Call +} + +// SetServerlessAutoIndexingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.SetServerlessAutoIndexingApiParams +func (_e *PerformanceAdvisorApi_Expecter) SetServerlessAutoIndexingWithParams(ctx interface{}, args interface{}) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call { + return &PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call{Call: _e.mock.On("SetServerlessAutoIndexingWithParams", ctx, args)} +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) Run(run func(ctx context.Context, args *admin.SetServerlessAutoIndexingApiParams)) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.SetServerlessAutoIndexingApiParams)) + }) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) Return(_a0 admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call) RunAndReturn(run func(context.Context, *admin.SetServerlessAutoIndexingApiParams) admin.SetServerlessAutoIndexingApiRequest) *PerformanceAdvisorApi_SetServerlessAutoIndexingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewPerformanceAdvisorApi creates a new instance of PerformanceAdvisorApi. 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 NewPerformanceAdvisorApi(t interface { + mock.TestingT + Cleanup(func()) +}) *PerformanceAdvisorApi { + mock := &PerformanceAdvisorApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/private_endpoint_services_api.go b/mockadmin/private_endpoint_services_api.go new file mode 100644 index 000000000..39a4e1493 --- /dev/null +++ b/mockadmin/private_endpoint_services_api.go @@ -0,0 +1,1505 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// PrivateEndpointServicesApi is an autogenerated mock type for the PrivateEndpointServicesApi type +type PrivateEndpointServicesApi struct { + mock.Mock +} + +type PrivateEndpointServicesApi_Expecter struct { + mock *mock.Mock +} + +func (_m *PrivateEndpointServicesApi) EXPECT() *PrivateEndpointServicesApi_Expecter { + return &PrivateEndpointServicesApi_Expecter{mock: &_m.Mock} +} + +// CreatePrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string, createEndpointRequest *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpoint") + } + + var r0 admin.CreatePrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest) + } else { + r0 = ret.Get(0).(admin.CreatePrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpoint' +type PrivateEndpointServicesApi_CreatePrivateEndpoint_Call struct { + *mock.Call +} + +// CreatePrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - endpointServiceId string +// - createEndpointRequest *admin.CreateEndpointRequest +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpoint(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}, createEndpointRequest interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpoint_Call{Call: _e.mock.On("CreatePrivateEndpoint", ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string, createEndpointRequest *admin.CreateEndpointRequest)) *PrivateEndpointServicesApi_CreatePrivateEndpoint_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.CreateEndpointRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) Return(_a0 admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateEndpointExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointExecute(r admin.CreatePrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpointExecute") + } + + var r0 *admin.PrivateLinkEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePrivateEndpointApiRequest) *admin.PrivateLinkEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PrivateLinkEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePrivateEndpointApiRequest) *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.CreatePrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpointExecute' +type PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call struct { + *mock.Call +} + +// CreatePrivateEndpointExecute is a helper method to define mock.On call +// - r admin.CreatePrivateEndpointApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call{Call: _e.mock.On("CreatePrivateEndpointExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call) Run(run func(r admin.CreatePrivateEndpointApiRequest)) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call) Return(_a0 *admin.PrivateLinkEndpoint, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call) RunAndReturn(run func(admin.CreatePrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProviderEndpointServiceRequest +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointService(ctx context.Context, groupId string, cloudProviderEndpointServiceRequest *admin.CloudProviderEndpointServiceRequest) admin.CreatePrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, groupId, cloudProviderEndpointServiceRequest) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpointService") + } + + var r0 admin.CreatePrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CloudProviderEndpointServiceRequest) admin.CreatePrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, groupId, cloudProviderEndpointServiceRequest) + } else { + r0 = ret.Get(0).(admin.CreatePrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpointService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpointService' +type PrivateEndpointServicesApi_CreatePrivateEndpointService_Call struct { + *mock.Call +} + +// CreatePrivateEndpointService is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProviderEndpointServiceRequest *admin.CloudProviderEndpointServiceRequest +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointService(ctx interface{}, groupId interface{}, cloudProviderEndpointServiceRequest interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpointService_Call{Call: _e.mock.On("CreatePrivateEndpointService", ctx, groupId, cloudProviderEndpointServiceRequest)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call) Run(run func(ctx context.Context, groupId string, cloudProviderEndpointServiceRequest *admin.CloudProviderEndpointServiceRequest)) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CloudProviderEndpointServiceRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call) Return(_a0 admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call) RunAndReturn(run func(context.Context, string, *admin.CloudProviderEndpointServiceRequest) admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateEndpointServiceExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointServiceExecute(r admin.CreatePrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpointServiceExecute") + } + + var r0 *admin.EndpointService + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreatePrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePrivateEndpointServiceApiRequest) *admin.EndpointService); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.EndpointService) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreatePrivateEndpointServiceApiRequest) *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.CreatePrivateEndpointServiceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpointServiceExecute' +type PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call struct { + *mock.Call +} + +// CreatePrivateEndpointServiceExecute is a helper method to define mock.On call +// - r admin.CreatePrivateEndpointServiceApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call{Call: _e.mock.On("CreatePrivateEndpointServiceExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call) Run(run func(r admin.CreatePrivateEndpointServiceApiRequest)) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePrivateEndpointServiceApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call) Return(_a0 *admin.EndpointService, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call) RunAndReturn(run func(admin.CreatePrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointServiceWithParams(ctx context.Context, args *admin.CreatePrivateEndpointServiceApiParams) admin.CreatePrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpointServiceWithParams") + } + + var r0 admin.CreatePrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePrivateEndpointServiceApiParams) admin.CreatePrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpointServiceWithParams' +type PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call struct { + *mock.Call +} + +// CreatePrivateEndpointServiceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePrivateEndpointServiceApiParams +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call{Call: _e.mock.On("CreatePrivateEndpointServiceWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePrivateEndpointServiceApiParams)) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePrivateEndpointServiceApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call) Return(_a0 admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePrivateEndpointServiceApiParams) admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreatePrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointWithParams(ctx context.Context, args *admin.CreatePrivateEndpointApiParams) admin.CreatePrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePrivateEndpointWithParams") + } + + var r0 admin.CreatePrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePrivateEndpointApiParams) admin.CreatePrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrivateEndpointWithParams' +type PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call struct { + *mock.Call +} + +// CreatePrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePrivateEndpointApiParams +func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call { + return &PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call{Call: _e.mock.On("CreatePrivateEndpointWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePrivateEndpointApiParams)) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePrivateEndpointApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call) Return(_a0 admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePrivateEndpointApiParams) admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointId, endpointServiceId +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string) admin.DeletePrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, endpointId, endpointServiceId) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpoint") + } + + var r0 admin.DeletePrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) admin.DeletePrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, endpointId, endpointServiceId) + } else { + r0 = ret.Get(0).(admin.DeletePrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpoint' +type PrivateEndpointServicesApi_DeletePrivateEndpoint_Call struct { + *mock.Call +} + +// DeletePrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - endpointId string +// - endpointServiceId string +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpoint(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointId interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpoint_Call{Call: _e.mock.On("DeletePrivateEndpoint", ctx, groupId, cloudProvider, endpointId, endpointServiceId)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string)) *PrivateEndpointServicesApi_DeletePrivateEndpoint_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 *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call) Return(_a0 admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string, string) admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpointExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointExecute(r admin.DeletePrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpointExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointApiRequest) 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.DeletePrivateEndpointApiRequest) *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.DeletePrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpointExecute' +type PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call struct { + *mock.Call +} + +// DeletePrivateEndpointExecute is a helper method to define mock.On call +// - r admin.DeletePrivateEndpointApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call{Call: _e.mock.On("DeletePrivateEndpointExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call) Run(run func(r admin.DeletePrivateEndpointApiRequest)) *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call) RunAndReturn(run func(admin.DeletePrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)) *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointService(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string) admin.DeletePrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpointService") + } + + var r0 admin.DeletePrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeletePrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, endpointServiceId) + } else { + r0 = ret.Get(0).(admin.DeletePrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpointService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpointService' +type PrivateEndpointServicesApi_DeletePrivateEndpointService_Call struct { + *mock.Call +} + +// DeletePrivateEndpointService is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - endpointServiceId string +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointService(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpointService_Call{Call: _e.mock.On("DeletePrivateEndpointService", ctx, groupId, cloudProvider, endpointServiceId)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string)) *PrivateEndpointServicesApi_DeletePrivateEndpointService_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 *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call) Return(_a0 admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpointServiceExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointServiceExecute(r admin.DeletePrivateEndpointServiceApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpointServiceExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointServiceApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointServiceApiRequest) 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.DeletePrivateEndpointServiceApiRequest) *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.DeletePrivateEndpointServiceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpointServiceExecute' +type PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call struct { + *mock.Call +} + +// DeletePrivateEndpointServiceExecute is a helper method to define mock.On call +// - r admin.DeletePrivateEndpointServiceApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call{Call: _e.mock.On("DeletePrivateEndpointServiceExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call) Run(run func(r admin.DeletePrivateEndpointServiceApiRequest)) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePrivateEndpointServiceApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call) RunAndReturn(run func(admin.DeletePrivateEndpointServiceApiRequest) (map[string]interface{}, *http.Response, error)) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointServiceWithParams(ctx context.Context, args *admin.DeletePrivateEndpointServiceApiParams) admin.DeletePrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpointServiceWithParams") + } + + var r0 admin.DeletePrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePrivateEndpointServiceApiParams) admin.DeletePrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpointServiceWithParams' +type PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call struct { + *mock.Call +} + +// DeletePrivateEndpointServiceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePrivateEndpointServiceApiParams +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call{Call: _e.mock.On("DeletePrivateEndpointServiceWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePrivateEndpointServiceApiParams)) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePrivateEndpointServiceApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call) Return(_a0 admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePrivateEndpointServiceApiParams) admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointWithParams(ctx context.Context, args *admin.DeletePrivateEndpointApiParams) admin.DeletePrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePrivateEndpointWithParams") + } + + var r0 admin.DeletePrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePrivateEndpointApiParams) admin.DeletePrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrivateEndpointWithParams' +type PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call struct { + *mock.Call +} + +// DeletePrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePrivateEndpointApiParams +func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call { + return &PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call{Call: _e.mock.On("DeletePrivateEndpointWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePrivateEndpointApiParams)) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePrivateEndpointApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call) Return(_a0 admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePrivateEndpointApiParams) admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointId, endpointServiceId +func (_m *PrivateEndpointServicesApi) GetPrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string) admin.GetPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, endpointId, endpointServiceId) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpoint") + } + + var r0 admin.GetPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) admin.GetPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, endpointId, endpointServiceId) + } else { + r0 = ret.Get(0).(admin.GetPrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpoint' +type PrivateEndpointServicesApi_GetPrivateEndpoint_Call struct { + *mock.Call +} + +// GetPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - endpointId string +// - endpointServiceId string +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpoint(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointId interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_GetPrivateEndpoint_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpoint_Call{Call: _e.mock.On("GetPrivateEndpoint", ctx, groupId, cloudProvider, endpointId, endpointServiceId)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string)) *PrivateEndpointServicesApi_GetPrivateEndpoint_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 *PrivateEndpointServicesApi_GetPrivateEndpoint_Call) Return(_a0 admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string, string) admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpointExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) GetPrivateEndpointExecute(r admin.GetPrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpointExecute") + } + + var r0 *admin.PrivateLinkEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPrivateEndpointApiRequest) *admin.PrivateLinkEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PrivateLinkEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPrivateEndpointApiRequest) *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.GetPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpointExecute' +type PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call struct { + *mock.Call +} + +// GetPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.GetPrivateEndpointApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call{Call: _e.mock.On("GetPrivateEndpointExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call) Run(run func(r admin.GetPrivateEndpointApiRequest)) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call) Return(_a0 *admin.PrivateLinkEndpoint, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call) RunAndReturn(run func(admin.GetPrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId +func (_m *PrivateEndpointServicesApi) GetPrivateEndpointService(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string) admin.GetPrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpointService") + } + + var r0 admin.GetPrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetPrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider, endpointServiceId) + } else { + r0 = ret.Get(0).(admin.GetPrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetPrivateEndpointService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpointService' +type PrivateEndpointServicesApi_GetPrivateEndpointService_Call struct { + *mock.Call +} + +// GetPrivateEndpointService is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +// - endpointServiceId string +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointService(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointService_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpointService_Call{Call: _e.mock.On("GetPrivateEndpointService", ctx, groupId, cloudProvider, endpointServiceId)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointService_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string)) *PrivateEndpointServicesApi_GetPrivateEndpointService_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 *PrivateEndpointServicesApi_GetPrivateEndpointService_Call) Return(_a0 admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointService_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointService_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointService_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpointServiceExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) GetPrivateEndpointServiceExecute(r admin.GetPrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpointServiceExecute") + } + + var r0 *admin.EndpointService + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPrivateEndpointServiceApiRequest) *admin.EndpointService); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.EndpointService) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPrivateEndpointServiceApiRequest) *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.GetPrivateEndpointServiceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpointServiceExecute' +type PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call struct { + *mock.Call +} + +// GetPrivateEndpointServiceExecute is a helper method to define mock.On call +// - r admin.GetPrivateEndpointServiceApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call{Call: _e.mock.On("GetPrivateEndpointServiceExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call) Run(run func(r admin.GetPrivateEndpointServiceApiRequest)) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPrivateEndpointServiceApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call) Return(_a0 *admin.EndpointService, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call) RunAndReturn(run func(admin.GetPrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) GetPrivateEndpointServiceWithParams(ctx context.Context, args *admin.GetPrivateEndpointServiceApiParams) admin.GetPrivateEndpointServiceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpointServiceWithParams") + } + + var r0 admin.GetPrivateEndpointServiceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPrivateEndpointServiceApiParams) admin.GetPrivateEndpointServiceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPrivateEndpointServiceApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpointServiceWithParams' +type PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call struct { + *mock.Call +} + +// GetPrivateEndpointServiceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPrivateEndpointServiceApiParams +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call{Call: _e.mock.On("GetPrivateEndpointServiceWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPrivateEndpointServiceApiParams)) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPrivateEndpointServiceApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call) Return(_a0 admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPrivateEndpointServiceApiParams) admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) GetPrivateEndpointWithParams(ctx context.Context, args *admin.GetPrivateEndpointApiParams) admin.GetPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPrivateEndpointWithParams") + } + + var r0 admin.GetPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPrivateEndpointApiParams) admin.GetPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPrivateEndpointApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateEndpointWithParams' +type PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// GetPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPrivateEndpointApiParams +func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call { + return &PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call{Call: _e.mock.On("GetPrivateEndpointWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPrivateEndpointApiParams)) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call) Return(_a0 admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPrivateEndpointApiParams) admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetRegionalizedPrivateEndpointSetting provides a mock function with given fields: ctx, groupId +func (_m *PrivateEndpointServicesApi) GetRegionalizedPrivateEndpointSetting(ctx context.Context, groupId string) admin.GetRegionalizedPrivateEndpointSettingApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetRegionalizedPrivateEndpointSetting") + } + + var r0 admin.GetRegionalizedPrivateEndpointSettingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetRegionalizedPrivateEndpointSettingApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetRegionalizedPrivateEndpointSettingApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegionalizedPrivateEndpointSetting' +type PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call struct { + *mock.Call +} + +// GetRegionalizedPrivateEndpointSetting is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *PrivateEndpointServicesApi_Expecter) GetRegionalizedPrivateEndpointSetting(ctx interface{}, groupId interface{}) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call { + return &PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call{Call: _e.mock.On("GetRegionalizedPrivateEndpointSetting", ctx, groupId)} +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call) Run(run func(ctx context.Context, groupId string)) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call) Return(_a0 admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call) RunAndReturn(run func(context.Context, string) admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call { + _c.Call.Return(run) + return _c +} + +// GetRegionalizedPrivateEndpointSettingExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) GetRegionalizedPrivateEndpointSettingExecute(r admin.GetRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetRegionalizedPrivateEndpointSettingExecute") + } + + var r0 *admin.ProjectSettingItem + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) *admin.ProjectSettingItem); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ProjectSettingItem) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) *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.GetRegionalizedPrivateEndpointSettingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegionalizedPrivateEndpointSettingExecute' +type PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call struct { + *mock.Call +} + +// GetRegionalizedPrivateEndpointSettingExecute is a helper method to define mock.On call +// - r admin.GetRegionalizedPrivateEndpointSettingApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) GetRegionalizedPrivateEndpointSettingExecute(r interface{}) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call { + return &PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call{Call: _e.mock.On("GetRegionalizedPrivateEndpointSettingExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call) Run(run func(r admin.GetRegionalizedPrivateEndpointSettingApiRequest)) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetRegionalizedPrivateEndpointSettingApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call) Return(_a0 *admin.ProjectSettingItem, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call) RunAndReturn(run func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetRegionalizedPrivateEndpointSettingWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) GetRegionalizedPrivateEndpointSettingWithParams(ctx context.Context, args *admin.GetRegionalizedPrivateEndpointSettingApiParams) admin.GetRegionalizedPrivateEndpointSettingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetRegionalizedPrivateEndpointSettingWithParams") + } + + var r0 admin.GetRegionalizedPrivateEndpointSettingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetRegionalizedPrivateEndpointSettingApiParams) admin.GetRegionalizedPrivateEndpointSettingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetRegionalizedPrivateEndpointSettingApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegionalizedPrivateEndpointSettingWithParams' +type PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call struct { + *mock.Call +} + +// GetRegionalizedPrivateEndpointSettingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetRegionalizedPrivateEndpointSettingApiParams +func (_e *PrivateEndpointServicesApi_Expecter) GetRegionalizedPrivateEndpointSettingWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call { + return &PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call{Call: _e.mock.On("GetRegionalizedPrivateEndpointSettingWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call) Run(run func(ctx context.Context, args *admin.GetRegionalizedPrivateEndpointSettingApiParams)) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetRegionalizedPrivateEndpointSettingApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call) Return(_a0 admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetRegionalizedPrivateEndpointSettingApiParams) admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListPrivateEndpointServices provides a mock function with given fields: ctx, groupId, cloudProvider +func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServices(ctx context.Context, groupId string, cloudProvider string) admin.ListPrivateEndpointServicesApiRequest { + ret := _m.Called(ctx, groupId, cloudProvider) + + if len(ret) == 0 { + panic("no return value specified for ListPrivateEndpointServices") + } + + var r0 admin.ListPrivateEndpointServicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListPrivateEndpointServicesApiRequest); ok { + r0 = rf(ctx, groupId, cloudProvider) + } else { + r0 = ret.Get(0).(admin.ListPrivateEndpointServicesApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_ListPrivateEndpointServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPrivateEndpointServices' +type PrivateEndpointServicesApi_ListPrivateEndpointServices_Call struct { + *mock.Call +} + +// ListPrivateEndpointServices is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - cloudProvider string +func (_e *PrivateEndpointServicesApi_Expecter) ListPrivateEndpointServices(ctx interface{}, groupId interface{}, cloudProvider interface{}) *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call { + return &PrivateEndpointServicesApi_ListPrivateEndpointServices_Call{Call: _e.mock.On("ListPrivateEndpointServices", ctx, groupId, cloudProvider)} +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string)) *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call) Return(_a0 admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call) RunAndReturn(run func(context.Context, string, string) admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call { + _c.Call.Return(run) + return _c +} + +// ListPrivateEndpointServicesExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServicesExecute(r admin.ListPrivateEndpointServicesApiRequest) ([]admin.EndpointService, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListPrivateEndpointServicesExecute") + } + + var r0 []admin.EndpointService + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListPrivateEndpointServicesApiRequest) ([]admin.EndpointService, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListPrivateEndpointServicesApiRequest) []admin.EndpointService); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.EndpointService) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListPrivateEndpointServicesApiRequest) *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.ListPrivateEndpointServicesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPrivateEndpointServicesExecute' +type PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call struct { + *mock.Call +} + +// ListPrivateEndpointServicesExecute is a helper method to define mock.On call +// - r admin.ListPrivateEndpointServicesApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) ListPrivateEndpointServicesExecute(r interface{}) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call { + return &PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call{Call: _e.mock.On("ListPrivateEndpointServicesExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call) Run(run func(r admin.ListPrivateEndpointServicesApiRequest)) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListPrivateEndpointServicesApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call) Return(_a0 []admin.EndpointService, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call) RunAndReturn(run func(admin.ListPrivateEndpointServicesApiRequest) ([]admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListPrivateEndpointServicesWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServicesWithParams(ctx context.Context, args *admin.ListPrivateEndpointServicesApiParams) admin.ListPrivateEndpointServicesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListPrivateEndpointServicesWithParams") + } + + var r0 admin.ListPrivateEndpointServicesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListPrivateEndpointServicesApiParams) admin.ListPrivateEndpointServicesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListPrivateEndpointServicesApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPrivateEndpointServicesWithParams' +type PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call struct { + *mock.Call +} + +// ListPrivateEndpointServicesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListPrivateEndpointServicesApiParams +func (_e *PrivateEndpointServicesApi_Expecter) ListPrivateEndpointServicesWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call { + return &PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call{Call: _e.mock.On("ListPrivateEndpointServicesWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListPrivateEndpointServicesApiParams)) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListPrivateEndpointServicesApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call) Return(_a0 admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPrivateEndpointServicesApiParams) admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ToggleRegionalizedPrivateEndpointSetting provides a mock function with given fields: ctx, groupId, projectSettingItem +func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSetting(ctx context.Context, groupId string, projectSettingItem *admin.ProjectSettingItem) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest { + ret := _m.Called(ctx, groupId, projectSettingItem) + + if len(ret) == 0 { + panic("no return value specified for ToggleRegionalizedPrivateEndpointSetting") + } + + var r0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.ProjectSettingItem) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest); ok { + r0 = rf(ctx, groupId, projectSettingItem) + } else { + r0 = ret.Get(0).(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleRegionalizedPrivateEndpointSetting' +type PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call struct { + *mock.Call +} + +// ToggleRegionalizedPrivateEndpointSetting is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - projectSettingItem *admin.ProjectSettingItem +func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSetting(ctx interface{}, groupId interface{}, projectSettingItem interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call { + return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSetting", ctx, groupId, projectSettingItem)} +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call) Run(run func(ctx context.Context, groupId string, projectSettingItem *admin.ProjectSettingItem)) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.ProjectSettingItem)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call) Return(_a0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call) RunAndReturn(run func(context.Context, string, *admin.ProjectSettingItem) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call { + _c.Call.Return(run) + return _c +} + +// ToggleRegionalizedPrivateEndpointSettingExecute provides a mock function with given fields: r +func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSettingExecute(r admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ToggleRegionalizedPrivateEndpointSettingExecute") + } + + var r0 *admin.ProjectSettingItem + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *admin.ProjectSettingItem); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ProjectSettingItem) + } + } + + if rf, ok := ret.Get(1).(func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *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.ToggleRegionalizedPrivateEndpointSettingApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleRegionalizedPrivateEndpointSettingExecute' +type PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call struct { + *mock.Call +} + +// ToggleRegionalizedPrivateEndpointSettingExecute is a helper method to define mock.On call +// - r admin.ToggleRegionalizedPrivateEndpointSettingApiRequest +func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSettingExecute(r interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call { + return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSettingExecute", r)} +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call) Run(run func(r admin.ToggleRegionalizedPrivateEndpointSettingApiRequest)) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call) Return(_a0 *admin.ProjectSettingItem, _a1 *http.Response, _a2 error) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call) RunAndReturn(run func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call { + _c.Call.Return(run) + return _c +} + +// ToggleRegionalizedPrivateEndpointSettingWithParams provides a mock function with given fields: ctx, args +func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSettingWithParams(ctx context.Context, args *admin.ToggleRegionalizedPrivateEndpointSettingApiParams) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ToggleRegionalizedPrivateEndpointSettingWithParams") + } + + var r0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ToggleRegionalizedPrivateEndpointSettingApiParams) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) + } + + return r0 +} + +// PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleRegionalizedPrivateEndpointSettingWithParams' +type PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call struct { + *mock.Call +} + +// ToggleRegionalizedPrivateEndpointSettingWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ToggleRegionalizedPrivateEndpointSettingApiParams +func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSettingWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call { + return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSettingWithParams", ctx, args)} +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call) Run(run func(ctx context.Context, args *admin.ToggleRegionalizedPrivateEndpointSettingApiParams)) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ToggleRegionalizedPrivateEndpointSettingApiParams)) + }) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call) Return(_a0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call) RunAndReturn(run func(context.Context, *admin.ToggleRegionalizedPrivateEndpointSettingApiParams) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewPrivateEndpointServicesApi creates a new instance of PrivateEndpointServicesApi. 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 NewPrivateEndpointServicesApi(t interface { + mock.TestingT + Cleanup(func()) +}) *PrivateEndpointServicesApi { + mock := &PrivateEndpointServicesApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/programmatic_api_keys_api.go b/mockadmin/programmatic_api_keys_api.go new file mode 100644 index 000000000..fa04dda41 --- /dev/null +++ b/mockadmin/programmatic_api_keys_api.go @@ -0,0 +1,2312 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ProgrammaticAPIKeysApi is an autogenerated mock type for the ProgrammaticAPIKeysApi type +type ProgrammaticAPIKeysApi struct { + mock.Mock +} + +type ProgrammaticAPIKeysApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ProgrammaticAPIKeysApi) EXPECT() *ProgrammaticAPIKeysApi_Expecter { + return &ProgrammaticAPIKeysApi_Expecter{mock: &_m.Mock} +} + +// AddProjectApiKey provides a mock function with given fields: ctx, groupId, apiUserId, userAccessRoleAssignment +func (_m *ProgrammaticAPIKeysApi) AddProjectApiKey(ctx context.Context, groupId string, apiUserId string, userAccessRoleAssignment *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest { + ret := _m.Called(ctx, groupId, apiUserId, userAccessRoleAssignment) + + if len(ret) == 0 { + panic("no return value specified for AddProjectApiKey") + } + + var r0 admin.AddProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest); ok { + r0 = rf(ctx, groupId, apiUserId, userAccessRoleAssignment) + } else { + r0 = ret.Get(0).(admin.AddProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_AddProjectApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddProjectApiKey' +type ProgrammaticAPIKeysApi_AddProjectApiKey_Call struct { + *mock.Call +} + +// AddProjectApiKey is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - apiUserId string +// - userAccessRoleAssignment *[]admin.UserAccessRoleAssignment +func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKey(ctx interface{}, groupId interface{}, apiUserId interface{}, userAccessRoleAssignment interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call { + return &ProgrammaticAPIKeysApi_AddProjectApiKey_Call{Call: _e.mock.On("AddProjectApiKey", ctx, groupId, apiUserId, userAccessRoleAssignment)} +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) Run(run func(ctx context.Context, groupId string, apiUserId string, userAccessRoleAssignment *[]admin.UserAccessRoleAssignment)) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.UserAccessRoleAssignment)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) Return(_a0 admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call { + _c.Call.Return(run) + return _c +} + +// AddProjectApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) AddProjectApiKeyExecute(r admin.AddProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for AddProjectApiKeyExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.AddProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.AddProjectApiKeyApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.AddProjectApiKeyApiRequest) *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.AddProjectApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddProjectApiKeyExecute' +type ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call struct { + *mock.Call +} + +// AddProjectApiKeyExecute is a helper method to define mock.On call +// - r admin.AddProjectApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call{Call: _e.mock.On("AddProjectApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call) Run(run func(r admin.AddProjectApiKeyApiRequest)) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.AddProjectApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call) RunAndReturn(run func(admin.AddProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// AddProjectApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) AddProjectApiKeyWithParams(ctx context.Context, args *admin.AddProjectApiKeyApiParams) admin.AddProjectApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for AddProjectApiKeyWithParams") + } + + var r0 admin.AddProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.AddProjectApiKeyApiParams) admin.AddProjectApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.AddProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddProjectApiKeyWithParams' +type ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call struct { + *mock.Call +} + +// AddProjectApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.AddProjectApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call{Call: _e.mock.On("AddProjectApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.AddProjectApiKeyApiParams)) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.AddProjectApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call) Return(_a0 admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddProjectApiKeyApiParams) admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKey provides a mock function with given fields: ctx, orgId, createAtlasOrganizationApiKey +func (_m *ProgrammaticAPIKeysApi) CreateApiKey(ctx context.Context, orgId string, createAtlasOrganizationApiKey *admin.CreateAtlasOrganizationApiKey) admin.CreateApiKeyApiRequest { + ret := _m.Called(ctx, orgId, createAtlasOrganizationApiKey) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKey") + } + + var r0 admin.CreateApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CreateAtlasOrganizationApiKey) admin.CreateApiKeyApiRequest); ok { + r0 = rf(ctx, orgId, createAtlasOrganizationApiKey) + } else { + r0 = ret.Get(0).(admin.CreateApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKey' +type ProgrammaticAPIKeysApi_CreateApiKey_Call struct { + *mock.Call +} + +// CreateApiKey is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - createAtlasOrganizationApiKey *admin.CreateAtlasOrganizationApiKey +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKey(ctx interface{}, orgId interface{}, createAtlasOrganizationApiKey interface{}) *ProgrammaticAPIKeysApi_CreateApiKey_Call { + return &ProgrammaticAPIKeysApi_CreateApiKey_Call{Call: _e.mock.On("CreateApiKey", ctx, orgId, createAtlasOrganizationApiKey)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKey_Call) Run(run func(ctx context.Context, orgId string, createAtlasOrganizationApiKey *admin.CreateAtlasOrganizationApiKey)) *ProgrammaticAPIKeysApi_CreateApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CreateAtlasOrganizationApiKey)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKey_Call) Return(_a0 admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKey_Call) RunAndReturn(run func(context.Context, string, *admin.CreateAtlasOrganizationApiKey) admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKey_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKeyAccessList provides a mock function with given fields: ctx, orgId, apiUserId, userAccessListRequest +func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessList(ctx context.Context, orgId string, apiUserId string, userAccessListRequest *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest { + ret := _m.Called(ctx, orgId, apiUserId, userAccessListRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKeyAccessList") + } + + var r0 admin.CreateApiKeyAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId, userAccessListRequest) + } else { + r0 = ret.Get(0).(admin.CreateApiKeyAccessListApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKeyAccessList' +type ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call struct { + *mock.Call +} + +// CreateApiKeyAccessList is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +// - userAccessListRequest *[]admin.UserAccessListRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessList(ctx interface{}, orgId interface{}, apiUserId interface{}, userAccessListRequest interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call { + return &ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call{Call: _e.mock.On("CreateApiKeyAccessList", ctx, orgId, apiUserId, userAccessListRequest)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, userAccessListRequest *[]admin.UserAccessListRequest)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.UserAccessListRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) Return(_a0 admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKeyAccessListExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessListExecute(r admin.CreateApiKeyAccessListApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKeyAccessListExecute") + } + + var r0 *admin.PaginatedApiUserAccessListResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateApiKeyAccessListApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateApiKeyAccessListApiRequest) *admin.PaginatedApiUserAccessListResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiUserAccessListResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateApiKeyAccessListApiRequest) *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.CreateApiKeyAccessListApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKeyAccessListExecute' +type ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call struct { + *mock.Call +} + +// CreateApiKeyAccessListExecute is a helper method to define mock.On call +// - r admin.CreateApiKeyAccessListApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessListExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call { + return &ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call{Call: _e.mock.On("CreateApiKeyAccessListExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call) Run(run func(r admin.CreateApiKeyAccessListApiRequest)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateApiKeyAccessListApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call) Return(_a0 *admin.PaginatedApiUserAccessListResponse, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call) RunAndReturn(run func(admin.CreateApiKeyAccessListApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKeyAccessListWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessListWithParams(ctx context.Context, args *admin.CreateApiKeyAccessListApiParams) admin.CreateApiKeyAccessListApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKeyAccessListWithParams") + } + + var r0 admin.CreateApiKeyAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateApiKeyAccessListApiParams) admin.CreateApiKeyAccessListApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateApiKeyAccessListApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKeyAccessListWithParams' +type ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call struct { + *mock.Call +} + +// CreateApiKeyAccessListWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateApiKeyAccessListApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessListWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call { + return &ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call{Call: _e.mock.On("CreateApiKeyAccessListWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateApiKeyAccessListApiParams)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateApiKeyAccessListApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call) Return(_a0 admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateApiKeyAccessListApiParams) admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) CreateApiKeyExecute(r admin.CreateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKeyExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateApiKeyApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateApiKeyApiRequest) *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.CreateApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKeyExecute' +type ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call struct { + *mock.Call +} + +// CreateApiKeyExecute is a helper method to define mock.On call +// - r admin.CreateApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call{Call: _e.mock.On("CreateApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call) Run(run func(r admin.CreateApiKeyApiRequest)) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call) RunAndReturn(run func(admin.CreateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) CreateApiKeyWithParams(ctx context.Context, args *admin.CreateApiKeyApiParams) admin.CreateApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateApiKeyWithParams") + } + + var r0 admin.CreateApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateApiKeyApiParams) admin.CreateApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateApiKeyWithParams' +type ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call struct { + *mock.Call +} + +// CreateApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call{Call: _e.mock.On("CreateApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateApiKeyApiParams)) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call) Return(_a0 admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateApiKeyApiParams) admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateProjectApiKey provides a mock function with given fields: ctx, groupId, createAtlasProjectApiKey +func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKey(ctx context.Context, groupId string, createAtlasProjectApiKey *admin.CreateAtlasProjectApiKey) admin.CreateProjectApiKeyApiRequest { + ret := _m.Called(ctx, groupId, createAtlasProjectApiKey) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectApiKey") + } + + var r0 admin.CreateProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.CreateAtlasProjectApiKey) admin.CreateProjectApiKeyApiRequest); ok { + r0 = rf(ctx, groupId, createAtlasProjectApiKey) + } else { + r0 = ret.Get(0).(admin.CreateProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateProjectApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectApiKey' +type ProgrammaticAPIKeysApi_CreateProjectApiKey_Call struct { + *mock.Call +} + +// CreateProjectApiKey is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - createAtlasProjectApiKey *admin.CreateAtlasProjectApiKey +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKey(ctx interface{}, groupId interface{}, createAtlasProjectApiKey interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call { + return &ProgrammaticAPIKeysApi_CreateProjectApiKey_Call{Call: _e.mock.On("CreateProjectApiKey", ctx, groupId, createAtlasProjectApiKey)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call) Run(run func(ctx context.Context, groupId string, createAtlasProjectApiKey *admin.CreateAtlasProjectApiKey)) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.CreateAtlasProjectApiKey)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call) Return(_a0 admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call) RunAndReturn(run func(context.Context, string, *admin.CreateAtlasProjectApiKey) admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call { + _c.Call.Return(run) + return _c +} + +// CreateProjectApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKeyExecute(r admin.CreateProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectApiKeyExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateProjectApiKeyApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateProjectApiKeyApiRequest) *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.CreateProjectApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectApiKeyExecute' +type ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call struct { + *mock.Call +} + +// CreateProjectApiKeyExecute is a helper method to define mock.On call +// - r admin.CreateProjectApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call{Call: _e.mock.On("CreateProjectApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call) Run(run func(r admin.CreateProjectApiKeyApiRequest)) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateProjectApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call) RunAndReturn(run func(admin.CreateProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateProjectApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKeyWithParams(ctx context.Context, args *admin.CreateProjectApiKeyApiParams) admin.CreateProjectApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectApiKeyWithParams") + } + + var r0 admin.CreateProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateProjectApiKeyApiParams) admin.CreateProjectApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectApiKeyWithParams' +type ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call struct { + *mock.Call +} + +// CreateProjectApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateProjectApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call{Call: _e.mock.On("CreateProjectApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateProjectApiKeyApiParams)) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateProjectApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call) Return(_a0 admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateProjectApiKeyApiParams) admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKey provides a mock function with given fields: ctx, orgId, apiUserId +func (_m *ProgrammaticAPIKeysApi) DeleteApiKey(ctx context.Context, orgId string, apiUserId string) admin.DeleteApiKeyApiRequest { + ret := _m.Called(ctx, orgId, apiUserId) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKey") + } + + var r0 admin.DeleteApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteApiKeyApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId) + } else { + r0 = ret.Get(0).(admin.DeleteApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_DeleteApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKey' +type ProgrammaticAPIKeysApi_DeleteApiKey_Call struct { + *mock.Call +} + +// DeleteApiKey is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKey(ctx interface{}, orgId interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_DeleteApiKey_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKey_Call{Call: _e.mock.On("DeleteApiKey", ctx, orgId, apiUserId)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKey_Call) Run(run func(ctx context.Context, orgId string, apiUserId string)) *ProgrammaticAPIKeysApi_DeleteApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKey_Call) Return(_a0 admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKey_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKey_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKeyAccessListEntry provides a mock function with given fields: ctx, orgId, apiUserId, ipAddress +func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyAccessListEntry(ctx context.Context, orgId string, apiUserId string, ipAddress string) admin.DeleteApiKeyAccessListEntryApiRequest { + ret := _m.Called(ctx, orgId, apiUserId, ipAddress) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKeyAccessListEntry") + } + + var r0 admin.DeleteApiKeyAccessListEntryApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteApiKeyAccessListEntryApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId, ipAddress) + } else { + r0 = ret.Get(0).(admin.DeleteApiKeyAccessListEntryApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKeyAccessListEntry' +type ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call struct { + *mock.Call +} + +// DeleteApiKeyAccessListEntry is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +// - ipAddress string +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntry(ctx interface{}, orgId interface{}, apiUserId interface{}, ipAddress interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntry", ctx, orgId, apiUserId, ipAddress)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, ipAddress string)) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_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 *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call) Return(_a0 admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKeyAccessListEntryExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyAccessListEntryExecute(r admin.DeleteApiKeyAccessListEntryApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKeyAccessListEntryExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteApiKeyAccessListEntryApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteApiKeyAccessListEntryApiRequest) 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.DeleteApiKeyAccessListEntryApiRequest) *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.DeleteApiKeyAccessListEntryApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKeyAccessListEntryExecute' +type ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call struct { + *mock.Call +} + +// DeleteApiKeyAccessListEntryExecute is a helper method to define mock.On call +// - r admin.DeleteApiKeyAccessListEntryApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntryExecute(r interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntryExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call) Run(run func(r admin.DeleteApiKeyAccessListEntryApiRequest)) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteApiKeyAccessListEntryApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call) RunAndReturn(run func(admin.DeleteApiKeyAccessListEntryApiRequest) (map[string]interface{}, *http.Response, error)) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKeyAccessListEntryWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyAccessListEntryWithParams(ctx context.Context, args *admin.DeleteApiKeyAccessListEntryApiParams) admin.DeleteApiKeyAccessListEntryApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKeyAccessListEntryWithParams") + } + + var r0 admin.DeleteApiKeyAccessListEntryApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteApiKeyAccessListEntryApiParams) admin.DeleteApiKeyAccessListEntryApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteApiKeyAccessListEntryApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKeyAccessListEntryWithParams' +type ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call struct { + *mock.Call +} + +// DeleteApiKeyAccessListEntryWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteApiKeyAccessListEntryApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntryWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntryWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteApiKeyAccessListEntryApiParams)) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteApiKeyAccessListEntryApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call) Return(_a0 admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteApiKeyAccessListEntryApiParams) admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyExecute(r admin.DeleteApiKeyApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKeyExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteApiKeyApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteApiKeyApiRequest) 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.DeleteApiKeyApiRequest) *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.DeleteApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKeyExecute' +type ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call struct { + *mock.Call +} + +// DeleteApiKeyExecute is a helper method to define mock.On call +// - r admin.DeleteApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call{Call: _e.mock.On("DeleteApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call) Run(run func(r admin.DeleteApiKeyApiRequest)) *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call) RunAndReturn(run func(admin.DeleteApiKeyApiRequest) (map[string]interface{}, *http.Response, error)) *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyWithParams(ctx context.Context, args *admin.DeleteApiKeyApiParams) admin.DeleteApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteApiKeyWithParams") + } + + var r0 admin.DeleteApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteApiKeyApiParams) admin.DeleteApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteApiKeyWithParams' +type ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call struct { + *mock.Call +} + +// DeleteApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call{Call: _e.mock.On("DeleteApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteApiKeyApiParams)) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call) Return(_a0 admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteApiKeyApiParams) admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKey provides a mock function with given fields: ctx, orgId, apiUserId +func (_m *ProgrammaticAPIKeysApi) GetApiKey(ctx context.Context, orgId string, apiUserId string) admin.GetApiKeyApiRequest { + ret := _m.Called(ctx, orgId, apiUserId) + + if len(ret) == 0 { + panic("no return value specified for GetApiKey") + } + + var r0 admin.GetApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetApiKeyApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId) + } else { + r0 = ret.Get(0).(admin.GetApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_GetApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKey' +type ProgrammaticAPIKeysApi_GetApiKey_Call struct { + *mock.Call +} + +// GetApiKey is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKey(ctx interface{}, orgId interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_GetApiKey_Call { + return &ProgrammaticAPIKeysApi_GetApiKey_Call{Call: _e.mock.On("GetApiKey", ctx, orgId, apiUserId)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKey_Call) Run(run func(ctx context.Context, orgId string, apiUserId string)) *ProgrammaticAPIKeysApi_GetApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKey_Call) Return(_a0 admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKey_Call) RunAndReturn(run func(context.Context, string, string) admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKey_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyAccessList provides a mock function with given fields: ctx, orgId, ipAddress, apiUserId +func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessList(ctx context.Context, orgId string, ipAddress string, apiUserId string) admin.GetApiKeyAccessListApiRequest { + ret := _m.Called(ctx, orgId, ipAddress, apiUserId) + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyAccessList") + } + + var r0 admin.GetApiKeyAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetApiKeyAccessListApiRequest); ok { + r0 = rf(ctx, orgId, ipAddress, apiUserId) + } else { + r0 = ret.Get(0).(admin.GetApiKeyAccessListApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyAccessList' +type ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call struct { + *mock.Call +} + +// GetApiKeyAccessList is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - ipAddress string +// - apiUserId string +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessList(ctx interface{}, orgId interface{}, ipAddress interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call { + return &ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call{Call: _e.mock.On("GetApiKeyAccessList", ctx, orgId, ipAddress, apiUserId)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call) Run(run func(ctx context.Context, orgId string, ipAddress string, apiUserId string)) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_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 *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call) Return(_a0 admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyAccessListExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessListExecute(r admin.GetApiKeyAccessListApiRequest) (*admin.UserAccessListResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyAccessListExecute") + } + + var r0 *admin.UserAccessListResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetApiKeyAccessListApiRequest) (*admin.UserAccessListResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetApiKeyAccessListApiRequest) *admin.UserAccessListResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserAccessListResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetApiKeyAccessListApiRequest) *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.GetApiKeyAccessListApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyAccessListExecute' +type ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call struct { + *mock.Call +} + +// GetApiKeyAccessListExecute is a helper method to define mock.On call +// - r admin.GetApiKeyAccessListApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessListExecute(r interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call { + return &ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call{Call: _e.mock.On("GetApiKeyAccessListExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call) Run(run func(r admin.GetApiKeyAccessListApiRequest)) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetApiKeyAccessListApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call) Return(_a0 *admin.UserAccessListResponse, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call) RunAndReturn(run func(admin.GetApiKeyAccessListApiRequest) (*admin.UserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyAccessListWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessListWithParams(ctx context.Context, args *admin.GetApiKeyAccessListApiParams) admin.GetApiKeyAccessListApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyAccessListWithParams") + } + + var r0 admin.GetApiKeyAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetApiKeyAccessListApiParams) admin.GetApiKeyAccessListApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetApiKeyAccessListApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyAccessListWithParams' +type ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call struct { + *mock.Call +} + +// GetApiKeyAccessListWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetApiKeyAccessListApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessListWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call { + return &ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call{Call: _e.mock.On("GetApiKeyAccessListWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call) Run(run func(ctx context.Context, args *admin.GetApiKeyAccessListApiParams)) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetApiKeyAccessListApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call) Return(_a0 admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetApiKeyAccessListApiParams) admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) GetApiKeyExecute(r admin.GetApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetApiKeyApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetApiKeyApiRequest) *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.GetApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_GetApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyExecute' +type ProgrammaticAPIKeysApi_GetApiKeyExecute_Call struct { + *mock.Call +} + +// GetApiKeyExecute is a helper method to define mock.On call +// - r admin.GetApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_GetApiKeyExecute_Call{Call: _e.mock.On("GetApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call) Run(run func(r admin.GetApiKeyApiRequest)) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call) RunAndReturn(run func(admin.GetApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) GetApiKeyWithParams(ctx context.Context, args *admin.GetApiKeyApiParams) admin.GetApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyWithParams") + } + + var r0 admin.GetApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetApiKeyApiParams) admin.GetApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyWithParams' +type ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call struct { + *mock.Call +} + +// GetApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call{Call: _e.mock.On("GetApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.GetApiKeyApiParams)) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call) Return(_a0 admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetApiKeyApiParams) admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeyAccessListsEntries provides a mock function with given fields: ctx, orgId, apiUserId +func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntries(ctx context.Context, orgId string, apiUserId string) admin.ListApiKeyAccessListsEntriesApiRequest { + ret := _m.Called(ctx, orgId, apiUserId) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeyAccessListsEntries") + } + + var r0 admin.ListApiKeyAccessListsEntriesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListApiKeyAccessListsEntriesApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId) + } else { + r0 = ret.Get(0).(admin.ListApiKeyAccessListsEntriesApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeyAccessListsEntries' +type ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call struct { + *mock.Call +} + +// ListApiKeyAccessListsEntries is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeyAccessListsEntries(ctx interface{}, orgId interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call { + return &ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call{Call: _e.mock.On("ListApiKeyAccessListsEntries", ctx, orgId, apiUserId)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call) Run(run func(ctx context.Context, orgId string, apiUserId string)) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call) Return(_a0 admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call) RunAndReturn(run func(context.Context, string, string) admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeyAccessListsEntriesExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntriesExecute(r admin.ListApiKeyAccessListsEntriesApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeyAccessListsEntriesExecute") + } + + var r0 *admin.PaginatedApiUserAccessListResponse + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListApiKeyAccessListsEntriesApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListApiKeyAccessListsEntriesApiRequest) *admin.PaginatedApiUserAccessListResponse); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiUserAccessListResponse) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListApiKeyAccessListsEntriesApiRequest) *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.ListApiKeyAccessListsEntriesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeyAccessListsEntriesExecute' +type ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call struct { + *mock.Call +} + +// ListApiKeyAccessListsEntriesExecute is a helper method to define mock.On call +// - r admin.ListApiKeyAccessListsEntriesApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeyAccessListsEntriesExecute(r interface{}) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call { + return &ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call{Call: _e.mock.On("ListApiKeyAccessListsEntriesExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call) Run(run func(r admin.ListApiKeyAccessListsEntriesApiRequest)) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListApiKeyAccessListsEntriesApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call) Return(_a0 *admin.PaginatedApiUserAccessListResponse, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call) RunAndReturn(run func(admin.ListApiKeyAccessListsEntriesApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeyAccessListsEntriesWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntriesWithParams(ctx context.Context, args *admin.ListApiKeyAccessListsEntriesApiParams) admin.ListApiKeyAccessListsEntriesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeyAccessListsEntriesWithParams") + } + + var r0 admin.ListApiKeyAccessListsEntriesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListApiKeyAccessListsEntriesApiParams) admin.ListApiKeyAccessListsEntriesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListApiKeyAccessListsEntriesApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeyAccessListsEntriesWithParams' +type ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call struct { + *mock.Call +} + +// ListApiKeyAccessListsEntriesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListApiKeyAccessListsEntriesApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeyAccessListsEntriesWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call { + return &ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call{Call: _e.mock.On("ListApiKeyAccessListsEntriesWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListApiKeyAccessListsEntriesApiParams)) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListApiKeyAccessListsEntriesApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call) Return(_a0 admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListApiKeyAccessListsEntriesApiParams) admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeys provides a mock function with given fields: ctx, orgId +func (_m *ProgrammaticAPIKeysApi) ListApiKeys(ctx context.Context, orgId string) admin.ListApiKeysApiRequest { + ret := _m.Called(ctx, orgId) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeys") + } + + var r0 admin.ListApiKeysApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListApiKeysApiRequest); ok { + r0 = rf(ctx, orgId) + } else { + r0 = ret.Get(0).(admin.ListApiKeysApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListApiKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeys' +type ProgrammaticAPIKeysApi_ListApiKeys_Call struct { + *mock.Call +} + +// ListApiKeys is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeys(ctx interface{}, orgId interface{}) *ProgrammaticAPIKeysApi_ListApiKeys_Call { + return &ProgrammaticAPIKeysApi_ListApiKeys_Call{Call: _e.mock.On("ListApiKeys", ctx, orgId)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeys_Call) Run(run func(ctx context.Context, orgId string)) *ProgrammaticAPIKeysApi_ListApiKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeys_Call) Return(_a0 admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeys_Call) RunAndReturn(run func(context.Context, string) admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeys_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeysExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) ListApiKeysExecute(r admin.ListApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeysExecute") + } + + var r0 *admin.PaginatedApiApiUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListApiKeysApiRequest) *admin.PaginatedApiApiUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiApiUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListApiKeysApiRequest) *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.ListApiKeysApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_ListApiKeysExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeysExecute' +type ProgrammaticAPIKeysApi_ListApiKeysExecute_Call struct { + *mock.Call +} + +// ListApiKeysExecute is a helper method to define mock.On call +// - r admin.ListApiKeysApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeysExecute(r interface{}) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call { + return &ProgrammaticAPIKeysApi_ListApiKeysExecute_Call{Call: _e.mock.On("ListApiKeysExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call) Run(run func(r admin.ListApiKeysApiRequest)) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListApiKeysApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call) Return(_a0 *admin.PaginatedApiApiUser, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call) RunAndReturn(run func(admin.ListApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListApiKeysWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) ListApiKeysWithParams(ctx context.Context, args *admin.ListApiKeysApiParams) admin.ListApiKeysApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListApiKeysWithParams") + } + + var r0 admin.ListApiKeysApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListApiKeysApiParams) admin.ListApiKeysApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListApiKeysApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApiKeysWithParams' +type ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call struct { + *mock.Call +} + +// ListApiKeysWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListApiKeysApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeysWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call { + return &ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call{Call: _e.mock.On("ListApiKeysWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call) Run(run func(ctx context.Context, args *admin.ListApiKeysApiParams)) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListApiKeysApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call) Return(_a0 admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListApiKeysApiParams) admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectApiKeys provides a mock function with given fields: ctx, groupId +func (_m *ProgrammaticAPIKeysApi) ListProjectApiKeys(ctx context.Context, groupId string) admin.ListProjectApiKeysApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListProjectApiKeys") + } + + var r0 admin.ListProjectApiKeysApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectApiKeysApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListProjectApiKeysApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListProjectApiKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectApiKeys' +type ProgrammaticAPIKeysApi_ListProjectApiKeys_Call struct { + *mock.Call +} + +// ListProjectApiKeys is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *ProgrammaticAPIKeysApi_Expecter) ListProjectApiKeys(ctx interface{}, groupId interface{}) *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call { + return &ProgrammaticAPIKeysApi_ListProjectApiKeys_Call{Call: _e.mock.On("ListProjectApiKeys", ctx, groupId)} +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call) Run(run func(ctx context.Context, groupId string)) *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call) Return(_a0 admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectApiKeysExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) ListProjectApiKeysExecute(r admin.ListProjectApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListProjectApiKeysExecute") + } + + var r0 *admin.PaginatedApiApiUser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListProjectApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListProjectApiKeysApiRequest) *admin.PaginatedApiApiUser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiApiUser) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListProjectApiKeysApiRequest) *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.ListProjectApiKeysApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectApiKeysExecute' +type ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call struct { + *mock.Call +} + +// ListProjectApiKeysExecute is a helper method to define mock.On call +// - r admin.ListProjectApiKeysApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) ListProjectApiKeysExecute(r interface{}) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call { + return &ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call{Call: _e.mock.On("ListProjectApiKeysExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call) Run(run func(r admin.ListProjectApiKeysApiRequest)) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListProjectApiKeysApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call) Return(_a0 *admin.PaginatedApiApiUser, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call) RunAndReturn(run func(admin.ListProjectApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectApiKeysWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) ListProjectApiKeysWithParams(ctx context.Context, args *admin.ListProjectApiKeysApiParams) admin.ListProjectApiKeysApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListProjectApiKeysWithParams") + } + + var r0 admin.ListProjectApiKeysApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectApiKeysApiParams) admin.ListProjectApiKeysApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListProjectApiKeysApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectApiKeysWithParams' +type ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call struct { + *mock.Call +} + +// ListProjectApiKeysWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListProjectApiKeysApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) ListProjectApiKeysWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call { + return &ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call{Call: _e.mock.On("ListProjectApiKeysWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectApiKeysApiParams)) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListProjectApiKeysApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call) Return(_a0 admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectApiKeysApiParams) admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call { + _c.Call.Return(run) + return _c +} + +// RemoveProjectApiKey provides a mock function with given fields: ctx, groupId, apiUserId +func (_m *ProgrammaticAPIKeysApi) RemoveProjectApiKey(ctx context.Context, groupId string, apiUserId string) admin.RemoveProjectApiKeyApiRequest { + ret := _m.Called(ctx, groupId, apiUserId) + + if len(ret) == 0 { + panic("no return value specified for RemoveProjectApiKey") + } + + var r0 admin.RemoveProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveProjectApiKeyApiRequest); ok { + r0 = rf(ctx, groupId, apiUserId) + } else { + r0 = ret.Get(0).(admin.RemoveProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectApiKey' +type ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call struct { + *mock.Call +} + +// RemoveProjectApiKey is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - apiUserId string +func (_e *ProgrammaticAPIKeysApi_Expecter) RemoveProjectApiKey(ctx interface{}, groupId interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call { + return &ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call{Call: _e.mock.On("RemoveProjectApiKey", ctx, groupId, apiUserId)} +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call) Run(run func(ctx context.Context, groupId string, apiUserId string)) *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call) Return(_a0 admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call { + _c.Call.Return(run) + return _c +} + +// RemoveProjectApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) RemoveProjectApiKeyExecute(r admin.RemoveProjectApiKeyApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for RemoveProjectApiKeyExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.RemoveProjectApiKeyApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.RemoveProjectApiKeyApiRequest) 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.RemoveProjectApiKeyApiRequest) *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.RemoveProjectApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectApiKeyExecute' +type ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call struct { + *mock.Call +} + +// RemoveProjectApiKeyExecute is a helper method to define mock.On call +// - r admin.RemoveProjectApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) RemoveProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call{Call: _e.mock.On("RemoveProjectApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call) Run(run func(r admin.RemoveProjectApiKeyApiRequest)) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.RemoveProjectApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call) RunAndReturn(run func(admin.RemoveProjectApiKeyApiRequest) (map[string]interface{}, *http.Response, error)) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// RemoveProjectApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) RemoveProjectApiKeyWithParams(ctx context.Context, args *admin.RemoveProjectApiKeyApiParams) admin.RemoveProjectApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for RemoveProjectApiKeyWithParams") + } + + var r0 admin.RemoveProjectApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveProjectApiKeyApiParams) admin.RemoveProjectApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.RemoveProjectApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectApiKeyWithParams' +type ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call struct { + *mock.Call +} + +// RemoveProjectApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.RemoveProjectApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) RemoveProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call{Call: _e.mock.On("RemoveProjectApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveProjectApiKeyApiParams)) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.RemoveProjectApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call) Return(_a0 admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveProjectApiKeyApiParams) admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKey provides a mock function with given fields: ctx, orgId, apiUserId, updateAtlasOrganizationApiKey +func (_m *ProgrammaticAPIKeysApi) UpdateApiKey(ctx context.Context, orgId string, apiUserId string, updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey) admin.UpdateApiKeyApiRequest { + ret := _m.Called(ctx, orgId, apiUserId, updateAtlasOrganizationApiKey) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKey") + } + + var r0 admin.UpdateApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UpdateAtlasOrganizationApiKey) admin.UpdateApiKeyApiRequest); ok { + r0 = rf(ctx, orgId, apiUserId, updateAtlasOrganizationApiKey) + } else { + r0 = ret.Get(0).(admin.UpdateApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_UpdateApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKey' +type ProgrammaticAPIKeysApi_UpdateApiKey_Call struct { + *mock.Call +} + +// UpdateApiKey is a helper method to define mock.On call +// - ctx context.Context +// - orgId string +// - apiUserId string +// - updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKey(ctx interface{}, orgId interface{}, apiUserId interface{}, updateAtlasOrganizationApiKey interface{}) *ProgrammaticAPIKeysApi_UpdateApiKey_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKey_Call{Call: _e.mock.On("UpdateApiKey", ctx, orgId, apiUserId, updateAtlasOrganizationApiKey)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey)) *ProgrammaticAPIKeysApi_UpdateApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateAtlasOrganizationApiKey)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) Return(_a0 admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateAtlasOrganizationApiKey) admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKey_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKeyExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyExecute(r admin.UpdateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKeyExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateApiKeyApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateApiKeyApiRequest) *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.UpdateApiKeyApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKeyExecute' +type ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call struct { + *mock.Call +} + +// UpdateApiKeyExecute is a helper method to define mock.On call +// - r admin.UpdateApiKeyApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call{Call: _e.mock.On("UpdateApiKeyExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call) Run(run func(r admin.UpdateApiKeyApiRequest)) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateApiKeyApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call) RunAndReturn(run func(admin.UpdateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKeyRoles provides a mock function with given fields: ctx, groupId, apiUserId, updateAtlasProjectApiKey +func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRoles(ctx context.Context, groupId string, apiUserId string, updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey) admin.UpdateApiKeyRolesApiRequest { + ret := _m.Called(ctx, groupId, apiUserId, updateAtlasProjectApiKey) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKeyRoles") + } + + var r0 admin.UpdateApiKeyRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UpdateAtlasProjectApiKey) admin.UpdateApiKeyRolesApiRequest); ok { + r0 = rf(ctx, groupId, apiUserId, updateAtlasProjectApiKey) + } else { + r0 = ret.Get(0).(admin.UpdateApiKeyRolesApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKeyRoles' +type ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call struct { + *mock.Call +} + +// UpdateApiKeyRoles is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - apiUserId string +// - updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRoles(ctx interface{}, groupId interface{}, apiUserId interface{}, updateAtlasProjectApiKey interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call{Call: _e.mock.On("UpdateApiKeyRoles", ctx, groupId, apiUserId, updateAtlasProjectApiKey)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) Run(run func(ctx context.Context, groupId string, apiUserId string, updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey)) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateAtlasProjectApiKey)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) Return(_a0 admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateAtlasProjectApiKey) admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKeyRolesExecute provides a mock function with given fields: r +func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRolesExecute(r admin.UpdateApiKeyRolesApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKeyRolesExecute") + } + + var r0 *admin.ApiKeyUserDetails + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateApiKeyRolesApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateApiKeyRolesApiRequest) *admin.ApiKeyUserDetails); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ApiKeyUserDetails) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateApiKeyRolesApiRequest) *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.UpdateApiKeyRolesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKeyRolesExecute' +type ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call struct { + *mock.Call +} + +// UpdateApiKeyRolesExecute is a helper method to define mock.On call +// - r admin.UpdateApiKeyRolesApiRequest +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRolesExecute(r interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call{Call: _e.mock.On("UpdateApiKeyRolesExecute", r)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call) Run(run func(r admin.UpdateApiKeyRolesApiRequest)) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateApiKeyRolesApiRequest)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call) Return(_a0 *admin.ApiKeyUserDetails, _a1 *http.Response, _a2 error) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call) RunAndReturn(run func(admin.UpdateApiKeyRolesApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKeyRolesWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRolesWithParams(ctx context.Context, args *admin.UpdateApiKeyRolesApiParams) admin.UpdateApiKeyRolesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKeyRolesWithParams") + } + + var r0 admin.UpdateApiKeyRolesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateApiKeyRolesApiParams) admin.UpdateApiKeyRolesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateApiKeyRolesApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKeyRolesWithParams' +type ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call struct { + *mock.Call +} + +// UpdateApiKeyRolesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateApiKeyRolesApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRolesWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call{Call: _e.mock.On("UpdateApiKeyRolesWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateApiKeyRolesApiParams)) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateApiKeyRolesApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call) Return(_a0 admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateApiKeyRolesApiParams) admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateApiKeyWithParams provides a mock function with given fields: ctx, args +func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyWithParams(ctx context.Context, args *admin.UpdateApiKeyApiParams) admin.UpdateApiKeyApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateApiKeyWithParams") + } + + var r0 admin.UpdateApiKeyApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateApiKeyApiParams) admin.UpdateApiKeyApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateApiKeyApiRequest) + } + + return r0 +} + +// ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateApiKeyWithParams' +type ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call struct { + *mock.Call +} + +// UpdateApiKeyWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateApiKeyApiParams +func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call { + return &ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call{Call: _e.mock.On("UpdateApiKeyWithParams", ctx, args)} +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateApiKeyApiParams)) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateApiKeyApiParams)) + }) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call) Return(_a0 admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateApiKeyApiParams) admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewProgrammaticAPIKeysApi creates a new instance of ProgrammaticAPIKeysApi. 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 NewProgrammaticAPIKeysApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ProgrammaticAPIKeysApi { + mock := &ProgrammaticAPIKeysApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/project_ip_access_list_api.go b/mockadmin/project_ip_access_list_api.go new file mode 100644 index 000000000..712f9aca3 --- /dev/null +++ b/mockadmin/project_ip_access_list_api.go @@ -0,0 +1,849 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ProjectIPAccessListApi is an autogenerated mock type for the ProjectIPAccessListApi type +type ProjectIPAccessListApi struct { + mock.Mock +} + +type ProjectIPAccessListApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ProjectIPAccessListApi) EXPECT() *ProjectIPAccessListApi_Expecter { + return &ProjectIPAccessListApi_Expecter{mock: &_m.Mock} +} + +// CreateProjectIpAccessList provides a mock function with given fields: ctx, groupId, networkPermissionEntry +func (_m *ProjectIPAccessListApi) CreateProjectIpAccessList(ctx context.Context, groupId string, networkPermissionEntry *[]admin.NetworkPermissionEntry) admin.CreateProjectIpAccessListApiRequest { + ret := _m.Called(ctx, groupId, networkPermissionEntry) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectIpAccessList") + } + + var r0 admin.CreateProjectIpAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *[]admin.NetworkPermissionEntry) admin.CreateProjectIpAccessListApiRequest); ok { + r0 = rf(ctx, groupId, networkPermissionEntry) + } else { + r0 = ret.Get(0).(admin.CreateProjectIpAccessListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_CreateProjectIpAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectIpAccessList' +type ProjectIPAccessListApi_CreateProjectIpAccessList_Call struct { + *mock.Call +} + +// CreateProjectIpAccessList is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - networkPermissionEntry *[]admin.NetworkPermissionEntry +func (_e *ProjectIPAccessListApi_Expecter) CreateProjectIpAccessList(ctx interface{}, groupId interface{}, networkPermissionEntry interface{}) *ProjectIPAccessListApi_CreateProjectIpAccessList_Call { + return &ProjectIPAccessListApi_CreateProjectIpAccessList_Call{Call: _e.mock.On("CreateProjectIpAccessList", ctx, groupId, networkPermissionEntry)} +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessList_Call) Run(run func(ctx context.Context, groupId string, networkPermissionEntry *[]admin.NetworkPermissionEntry)) *ProjectIPAccessListApi_CreateProjectIpAccessList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*[]admin.NetworkPermissionEntry)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessList_Call) Return(_a0 admin.CreateProjectIpAccessListApiRequest) *ProjectIPAccessListApi_CreateProjectIpAccessList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessList_Call) RunAndReturn(run func(context.Context, string, *[]admin.NetworkPermissionEntry) admin.CreateProjectIpAccessListApiRequest) *ProjectIPAccessListApi_CreateProjectIpAccessList_Call { + _c.Call.Return(run) + return _c +} + +// CreateProjectIpAccessListExecute provides a mock function with given fields: r +func (_m *ProjectIPAccessListApi) CreateProjectIpAccessListExecute(r admin.CreateProjectIpAccessListApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectIpAccessListExecute") + } + + var r0 *admin.PaginatedNetworkAccess + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateProjectIpAccessListApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateProjectIpAccessListApiRequest) *admin.PaginatedNetworkAccess); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedNetworkAccess) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateProjectIpAccessListApiRequest) *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.CreateProjectIpAccessListApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectIpAccessListExecute' +type ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call struct { + *mock.Call +} + +// CreateProjectIpAccessListExecute is a helper method to define mock.On call +// - r admin.CreateProjectIpAccessListApiRequest +func (_e *ProjectIPAccessListApi_Expecter) CreateProjectIpAccessListExecute(r interface{}) *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call { + return &ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call{Call: _e.mock.On("CreateProjectIpAccessListExecute", r)} +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call) Run(run func(r admin.CreateProjectIpAccessListApiRequest)) *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateProjectIpAccessListApiRequest)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call) Return(_a0 *admin.PaginatedNetworkAccess, _a1 *http.Response, _a2 error) *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call) RunAndReturn(run func(admin.CreateProjectIpAccessListApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error)) *ProjectIPAccessListApi_CreateProjectIpAccessListExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateProjectIpAccessListWithParams provides a mock function with given fields: ctx, args +func (_m *ProjectIPAccessListApi) CreateProjectIpAccessListWithParams(ctx context.Context, args *admin.CreateProjectIpAccessListApiParams) admin.CreateProjectIpAccessListApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateProjectIpAccessListWithParams") + } + + var r0 admin.CreateProjectIpAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateProjectIpAccessListApiParams) admin.CreateProjectIpAccessListApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateProjectIpAccessListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProjectIpAccessListWithParams' +type ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call struct { + *mock.Call +} + +// CreateProjectIpAccessListWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateProjectIpAccessListApiParams +func (_e *ProjectIPAccessListApi_Expecter) CreateProjectIpAccessListWithParams(ctx interface{}, args interface{}) *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call { + return &ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call{Call: _e.mock.On("CreateProjectIpAccessListWithParams", ctx, args)} +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateProjectIpAccessListApiParams)) *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateProjectIpAccessListApiParams)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call) Return(_a0 admin.CreateProjectIpAccessListApiRequest) *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateProjectIpAccessListApiParams) admin.CreateProjectIpAccessListApiRequest) *ProjectIPAccessListApi_CreateProjectIpAccessListWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteProjectIpAccessList provides a mock function with given fields: ctx, groupId, entryValue +func (_m *ProjectIPAccessListApi) DeleteProjectIpAccessList(ctx context.Context, groupId string, entryValue string) admin.DeleteProjectIpAccessListApiRequest { + ret := _m.Called(ctx, groupId, entryValue) + + if len(ret) == 0 { + panic("no return value specified for DeleteProjectIpAccessList") + } + + var r0 admin.DeleteProjectIpAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteProjectIpAccessListApiRequest); ok { + r0 = rf(ctx, groupId, entryValue) + } else { + r0 = ret.Get(0).(admin.DeleteProjectIpAccessListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_DeleteProjectIpAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectIpAccessList' +type ProjectIPAccessListApi_DeleteProjectIpAccessList_Call struct { + *mock.Call +} + +// DeleteProjectIpAccessList is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - entryValue string +func (_e *ProjectIPAccessListApi_Expecter) DeleteProjectIpAccessList(ctx interface{}, groupId interface{}, entryValue interface{}) *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call { + return &ProjectIPAccessListApi_DeleteProjectIpAccessList_Call{Call: _e.mock.On("DeleteProjectIpAccessList", ctx, groupId, entryValue)} +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call) Run(run func(ctx context.Context, groupId string, entryValue string)) *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call) Return(_a0 admin.DeleteProjectIpAccessListApiRequest) *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteProjectIpAccessListApiRequest) *ProjectIPAccessListApi_DeleteProjectIpAccessList_Call { + _c.Call.Return(run) + return _c +} + +// DeleteProjectIpAccessListExecute provides a mock function with given fields: r +func (_m *ProjectIPAccessListApi) DeleteProjectIpAccessListExecute(r admin.DeleteProjectIpAccessListApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteProjectIpAccessListExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteProjectIpAccessListApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteProjectIpAccessListApiRequest) 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.DeleteProjectIpAccessListApiRequest) *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.DeleteProjectIpAccessListApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectIpAccessListExecute' +type ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call struct { + *mock.Call +} + +// DeleteProjectIpAccessListExecute is a helper method to define mock.On call +// - r admin.DeleteProjectIpAccessListApiRequest +func (_e *ProjectIPAccessListApi_Expecter) DeleteProjectIpAccessListExecute(r interface{}) *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call { + return &ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call{Call: _e.mock.On("DeleteProjectIpAccessListExecute", r)} +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call) Run(run func(r admin.DeleteProjectIpAccessListApiRequest)) *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteProjectIpAccessListApiRequest)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call) RunAndReturn(run func(admin.DeleteProjectIpAccessListApiRequest) (map[string]interface{}, *http.Response, error)) *ProjectIPAccessListApi_DeleteProjectIpAccessListExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteProjectIpAccessListWithParams provides a mock function with given fields: ctx, args +func (_m *ProjectIPAccessListApi) DeleteProjectIpAccessListWithParams(ctx context.Context, args *admin.DeleteProjectIpAccessListApiParams) admin.DeleteProjectIpAccessListApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteProjectIpAccessListWithParams") + } + + var r0 admin.DeleteProjectIpAccessListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteProjectIpAccessListApiParams) admin.DeleteProjectIpAccessListApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteProjectIpAccessListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProjectIpAccessListWithParams' +type ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call struct { + *mock.Call +} + +// DeleteProjectIpAccessListWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteProjectIpAccessListApiParams +func (_e *ProjectIPAccessListApi_Expecter) DeleteProjectIpAccessListWithParams(ctx interface{}, args interface{}) *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call { + return &ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call{Call: _e.mock.On("DeleteProjectIpAccessListWithParams", ctx, args)} +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteProjectIpAccessListApiParams)) *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteProjectIpAccessListApiParams)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call) Return(_a0 admin.DeleteProjectIpAccessListApiRequest) *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteProjectIpAccessListApiParams) admin.DeleteProjectIpAccessListApiRequest) *ProjectIPAccessListApi_DeleteProjectIpAccessListWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpAccessListStatus provides a mock function with given fields: ctx, groupId, entryValue +func (_m *ProjectIPAccessListApi) GetProjectIpAccessListStatus(ctx context.Context, groupId string, entryValue string) admin.GetProjectIpAccessListStatusApiRequest { + ret := _m.Called(ctx, groupId, entryValue) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpAccessListStatus") + } + + var r0 admin.GetProjectIpAccessListStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetProjectIpAccessListStatusApiRequest); ok { + r0 = rf(ctx, groupId, entryValue) + } else { + r0 = ret.Get(0).(admin.GetProjectIpAccessListStatusApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpAccessListStatus' +type ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call struct { + *mock.Call +} + +// GetProjectIpAccessListStatus is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - entryValue string +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpAccessListStatus(ctx interface{}, groupId interface{}, entryValue interface{}) *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call { + return &ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call{Call: _e.mock.On("GetProjectIpAccessListStatus", ctx, groupId, entryValue)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call) Run(run func(ctx context.Context, groupId string, entryValue string)) *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call) Return(_a0 admin.GetProjectIpAccessListStatusApiRequest) *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetProjectIpAccessListStatusApiRequest) *ProjectIPAccessListApi_GetProjectIpAccessListStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpAccessListStatusExecute provides a mock function with given fields: r +func (_m *ProjectIPAccessListApi) GetProjectIpAccessListStatusExecute(r admin.GetProjectIpAccessListStatusApiRequest) (*admin.NetworkPermissionEntryStatus, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpAccessListStatusExecute") + } + + var r0 *admin.NetworkPermissionEntryStatus + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetProjectIpAccessListStatusApiRequest) (*admin.NetworkPermissionEntryStatus, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetProjectIpAccessListStatusApiRequest) *admin.NetworkPermissionEntryStatus); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.NetworkPermissionEntryStatus) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetProjectIpAccessListStatusApiRequest) *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.GetProjectIpAccessListStatusApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpAccessListStatusExecute' +type ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call struct { + *mock.Call +} + +// GetProjectIpAccessListStatusExecute is a helper method to define mock.On call +// - r admin.GetProjectIpAccessListStatusApiRequest +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpAccessListStatusExecute(r interface{}) *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call { + return &ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call{Call: _e.mock.On("GetProjectIpAccessListStatusExecute", r)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call) Run(run func(r admin.GetProjectIpAccessListStatusApiRequest)) *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetProjectIpAccessListStatusApiRequest)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call) Return(_a0 *admin.NetworkPermissionEntryStatus, _a1 *http.Response, _a2 error) *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call) RunAndReturn(run func(admin.GetProjectIpAccessListStatusApiRequest) (*admin.NetworkPermissionEntryStatus, *http.Response, error)) *ProjectIPAccessListApi_GetProjectIpAccessListStatusExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpAccessListStatusWithParams provides a mock function with given fields: ctx, args +func (_m *ProjectIPAccessListApi) GetProjectIpAccessListStatusWithParams(ctx context.Context, args *admin.GetProjectIpAccessListStatusApiParams) admin.GetProjectIpAccessListStatusApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpAccessListStatusWithParams") + } + + var r0 admin.GetProjectIpAccessListStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectIpAccessListStatusApiParams) admin.GetProjectIpAccessListStatusApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetProjectIpAccessListStatusApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpAccessListStatusWithParams' +type ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call struct { + *mock.Call +} + +// GetProjectIpAccessListStatusWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetProjectIpAccessListStatusApiParams +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpAccessListStatusWithParams(ctx interface{}, args interface{}) *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call { + return &ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call{Call: _e.mock.On("GetProjectIpAccessListStatusWithParams", ctx, args)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectIpAccessListStatusApiParams)) *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetProjectIpAccessListStatusApiParams)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call) Return(_a0 admin.GetProjectIpAccessListStatusApiRequest) *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectIpAccessListStatusApiParams) admin.GetProjectIpAccessListStatusApiRequest) *ProjectIPAccessListApi_GetProjectIpAccessListStatusWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpList provides a mock function with given fields: ctx, groupId, entryValue +func (_m *ProjectIPAccessListApi) GetProjectIpList(ctx context.Context, groupId string, entryValue string) admin.GetProjectIpListApiRequest { + ret := _m.Called(ctx, groupId, entryValue) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpList") + } + + var r0 admin.GetProjectIpListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetProjectIpListApiRequest); ok { + r0 = rf(ctx, groupId, entryValue) + } else { + r0 = ret.Get(0).(admin.GetProjectIpListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_GetProjectIpList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpList' +type ProjectIPAccessListApi_GetProjectIpList_Call struct { + *mock.Call +} + +// GetProjectIpList is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - entryValue string +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpList(ctx interface{}, groupId interface{}, entryValue interface{}) *ProjectIPAccessListApi_GetProjectIpList_Call { + return &ProjectIPAccessListApi_GetProjectIpList_Call{Call: _e.mock.On("GetProjectIpList", ctx, groupId, entryValue)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpList_Call) Run(run func(ctx context.Context, groupId string, entryValue string)) *ProjectIPAccessListApi_GetProjectIpList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpList_Call) Return(_a0 admin.GetProjectIpListApiRequest) *ProjectIPAccessListApi_GetProjectIpList_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpList_Call) RunAndReturn(run func(context.Context, string, string) admin.GetProjectIpListApiRequest) *ProjectIPAccessListApi_GetProjectIpList_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpListExecute provides a mock function with given fields: r +func (_m *ProjectIPAccessListApi) GetProjectIpListExecute(r admin.GetProjectIpListApiRequest) (*admin.NetworkPermissionEntry, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpListExecute") + } + + var r0 *admin.NetworkPermissionEntry + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetProjectIpListApiRequest) (*admin.NetworkPermissionEntry, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetProjectIpListApiRequest) *admin.NetworkPermissionEntry); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.NetworkPermissionEntry) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetProjectIpListApiRequest) *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.GetProjectIpListApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProjectIPAccessListApi_GetProjectIpListExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpListExecute' +type ProjectIPAccessListApi_GetProjectIpListExecute_Call struct { + *mock.Call +} + +// GetProjectIpListExecute is a helper method to define mock.On call +// - r admin.GetProjectIpListApiRequest +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpListExecute(r interface{}) *ProjectIPAccessListApi_GetProjectIpListExecute_Call { + return &ProjectIPAccessListApi_GetProjectIpListExecute_Call{Call: _e.mock.On("GetProjectIpListExecute", r)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListExecute_Call) Run(run func(r admin.GetProjectIpListApiRequest)) *ProjectIPAccessListApi_GetProjectIpListExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetProjectIpListApiRequest)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListExecute_Call) Return(_a0 *admin.NetworkPermissionEntry, _a1 *http.Response, _a2 error) *ProjectIPAccessListApi_GetProjectIpListExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListExecute_Call) RunAndReturn(run func(admin.GetProjectIpListApiRequest) (*admin.NetworkPermissionEntry, *http.Response, error)) *ProjectIPAccessListApi_GetProjectIpListExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetProjectIpListWithParams provides a mock function with given fields: ctx, args +func (_m *ProjectIPAccessListApi) GetProjectIpListWithParams(ctx context.Context, args *admin.GetProjectIpListApiParams) admin.GetProjectIpListApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetProjectIpListWithParams") + } + + var r0 admin.GetProjectIpListApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetProjectIpListApiParams) admin.GetProjectIpListApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetProjectIpListApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_GetProjectIpListWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectIpListWithParams' +type ProjectIPAccessListApi_GetProjectIpListWithParams_Call struct { + *mock.Call +} + +// GetProjectIpListWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetProjectIpListApiParams +func (_e *ProjectIPAccessListApi_Expecter) GetProjectIpListWithParams(ctx interface{}, args interface{}) *ProjectIPAccessListApi_GetProjectIpListWithParams_Call { + return &ProjectIPAccessListApi_GetProjectIpListWithParams_Call{Call: _e.mock.On("GetProjectIpListWithParams", ctx, args)} +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListWithParams_Call) Run(run func(ctx context.Context, args *admin.GetProjectIpListApiParams)) *ProjectIPAccessListApi_GetProjectIpListWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetProjectIpListApiParams)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListWithParams_Call) Return(_a0 admin.GetProjectIpListApiRequest) *ProjectIPAccessListApi_GetProjectIpListWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_GetProjectIpListWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetProjectIpListApiParams) admin.GetProjectIpListApiRequest) *ProjectIPAccessListApi_GetProjectIpListWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectIpAccessLists provides a mock function with given fields: ctx, groupId +func (_m *ProjectIPAccessListApi) ListProjectIpAccessLists(ctx context.Context, groupId string) admin.ListProjectIpAccessListsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListProjectIpAccessLists") + } + + var r0 admin.ListProjectIpAccessListsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectIpAccessListsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListProjectIpAccessListsApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_ListProjectIpAccessLists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectIpAccessLists' +type ProjectIPAccessListApi_ListProjectIpAccessLists_Call struct { + *mock.Call +} + +// ListProjectIpAccessLists is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *ProjectIPAccessListApi_Expecter) ListProjectIpAccessLists(ctx interface{}, groupId interface{}) *ProjectIPAccessListApi_ListProjectIpAccessLists_Call { + return &ProjectIPAccessListApi_ListProjectIpAccessLists_Call{Call: _e.mock.On("ListProjectIpAccessLists", ctx, groupId)} +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessLists_Call) Run(run func(ctx context.Context, groupId string)) *ProjectIPAccessListApi_ListProjectIpAccessLists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessLists_Call) Return(_a0 admin.ListProjectIpAccessListsApiRequest) *ProjectIPAccessListApi_ListProjectIpAccessLists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessLists_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectIpAccessListsApiRequest) *ProjectIPAccessListApi_ListProjectIpAccessLists_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectIpAccessListsExecute provides a mock function with given fields: r +func (_m *ProjectIPAccessListApi) ListProjectIpAccessListsExecute(r admin.ListProjectIpAccessListsApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListProjectIpAccessListsExecute") + } + + var r0 *admin.PaginatedNetworkAccess + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListProjectIpAccessListsApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListProjectIpAccessListsApiRequest) *admin.PaginatedNetworkAccess); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedNetworkAccess) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListProjectIpAccessListsApiRequest) *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.ListProjectIpAccessListsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectIpAccessListsExecute' +type ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call struct { + *mock.Call +} + +// ListProjectIpAccessListsExecute is a helper method to define mock.On call +// - r admin.ListProjectIpAccessListsApiRequest +func (_e *ProjectIPAccessListApi_Expecter) ListProjectIpAccessListsExecute(r interface{}) *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call { + return &ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call{Call: _e.mock.On("ListProjectIpAccessListsExecute", r)} +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call) Run(run func(r admin.ListProjectIpAccessListsApiRequest)) *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListProjectIpAccessListsApiRequest)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call) Return(_a0 *admin.PaginatedNetworkAccess, _a1 *http.Response, _a2 error) *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call) RunAndReturn(run func(admin.ListProjectIpAccessListsApiRequest) (*admin.PaginatedNetworkAccess, *http.Response, error)) *ProjectIPAccessListApi_ListProjectIpAccessListsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListProjectIpAccessListsWithParams provides a mock function with given fields: ctx, args +func (_m *ProjectIPAccessListApi) ListProjectIpAccessListsWithParams(ctx context.Context, args *admin.ListProjectIpAccessListsApiParams) admin.ListProjectIpAccessListsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListProjectIpAccessListsWithParams") + } + + var r0 admin.ListProjectIpAccessListsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectIpAccessListsApiParams) admin.ListProjectIpAccessListsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListProjectIpAccessListsApiRequest) + } + + return r0 +} + +// ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectIpAccessListsWithParams' +type ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call struct { + *mock.Call +} + +// ListProjectIpAccessListsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListProjectIpAccessListsApiParams +func (_e *ProjectIPAccessListApi_Expecter) ListProjectIpAccessListsWithParams(ctx interface{}, args interface{}) *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call { + return &ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call{Call: _e.mock.On("ListProjectIpAccessListsWithParams", ctx, args)} +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectIpAccessListsApiParams)) *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListProjectIpAccessListsApiParams)) + }) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call) Return(_a0 admin.ListProjectIpAccessListsApiRequest) *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectIpAccessListsApiParams) admin.ListProjectIpAccessListsApiRequest) *ProjectIPAccessListApi_ListProjectIpAccessListsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewProjectIPAccessListApi creates a new instance of ProjectIPAccessListApi. 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 NewProjectIPAccessListApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ProjectIPAccessListApi { + mock := &ProjectIPAccessListApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/projects_api.go b/mockadmin/projects_api.go new file mode 100644 index 000000000..66f227a46 --- /dev/null +++ b/mockadmin/projects_api.go @@ -0,0 +1,3749 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +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/mockadmin/push_based_log_export_api.go b/mockadmin/push_based_log_export_api.go new file mode 100644 index 000000000..04447f339 --- /dev/null +++ b/mockadmin/push_based_log_export_api.go @@ -0,0 +1,659 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// PushBasedLogExportApi is an autogenerated mock type for the PushBasedLogExportApi type +type PushBasedLogExportApi struct { + mock.Mock +} + +type PushBasedLogExportApi_Expecter struct { + mock *mock.Mock +} + +func (_m *PushBasedLogExportApi) EXPECT() *PushBasedLogExportApi_Expecter { + return &PushBasedLogExportApi_Expecter{mock: &_m.Mock} +} + +// CreatePushBasedLogConfiguration provides a mock function with given fields: ctx, groupId, pushBasedLogExportProject +func (_m *PushBasedLogExportApi) CreatePushBasedLogConfiguration(ctx context.Context, groupId string, pushBasedLogExportProject *admin.PushBasedLogExportProject) admin.CreatePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, groupId, pushBasedLogExportProject) + + if len(ret) == 0 { + panic("no return value specified for CreatePushBasedLogConfiguration") + } + + var r0 admin.CreatePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.PushBasedLogExportProject) admin.CreatePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, pushBasedLogExportProject) + } else { + r0 = ret.Get(0).(admin.CreatePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushBasedLogConfiguration' +type PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call struct { + *mock.Call +} + +// CreatePushBasedLogConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pushBasedLogExportProject *admin.PushBasedLogExportProject +func (_e *PushBasedLogExportApi_Expecter) CreatePushBasedLogConfiguration(ctx interface{}, groupId interface{}, pushBasedLogExportProject interface{}) *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call { + return &PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call{Call: _e.mock.On("CreatePushBasedLogConfiguration", ctx, groupId, pushBasedLogExportProject)} +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call) Run(run func(ctx context.Context, groupId string, pushBasedLogExportProject *admin.PushBasedLogExportProject)) *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.PushBasedLogExportProject)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call) Return(_a0 admin.CreatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.PushBasedLogExportProject) admin.CreatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_CreatePushBasedLogConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// CreatePushBasedLogConfigurationExecute provides a mock function with given fields: r +func (_m *PushBasedLogExportApi) CreatePushBasedLogConfigurationExecute(r admin.CreatePushBasedLogConfigurationApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreatePushBasedLogConfigurationExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.CreatePushBasedLogConfigurationApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreatePushBasedLogConfigurationApiRequest) *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.CreatePushBasedLogConfigurationApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushBasedLogConfigurationExecute' +type PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call struct { + *mock.Call +} + +// CreatePushBasedLogConfigurationExecute is a helper method to define mock.On call +// - r admin.CreatePushBasedLogConfigurationApiRequest +func (_e *PushBasedLogExportApi_Expecter) CreatePushBasedLogConfigurationExecute(r interface{}) *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call { + return &PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call{Call: _e.mock.On("CreatePushBasedLogConfigurationExecute", r)} +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call) Run(run func(r admin.CreatePushBasedLogConfigurationApiRequest)) *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreatePushBasedLogConfigurationApiRequest)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call) Return(_a0 *http.Response, _a1 error) *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call) RunAndReturn(run func(admin.CreatePushBasedLogConfigurationApiRequest) (*http.Response, error)) *PushBasedLogExportApi_CreatePushBasedLogConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreatePushBasedLogConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *PushBasedLogExportApi) CreatePushBasedLogConfigurationWithParams(ctx context.Context, args *admin.CreatePushBasedLogConfigurationApiParams) admin.CreatePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreatePushBasedLogConfigurationWithParams") + } + + var r0 admin.CreatePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePushBasedLogConfigurationApiParams) admin.CreatePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreatePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushBasedLogConfigurationWithParams' +type PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call struct { + *mock.Call +} + +// CreatePushBasedLogConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreatePushBasedLogConfigurationApiParams +func (_e *PushBasedLogExportApi_Expecter) CreatePushBasedLogConfigurationWithParams(ctx interface{}, args interface{}) *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call { + return &PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call{Call: _e.mock.On("CreatePushBasedLogConfigurationWithParams", ctx, args)} +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePushBasedLogConfigurationApiParams)) *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreatePushBasedLogConfigurationApiParams)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call) Return(_a0 admin.CreatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePushBasedLogConfigurationApiParams) admin.CreatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_CreatePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeletePushBasedLogConfiguration provides a mock function with given fields: ctx, groupId +func (_m *PushBasedLogExportApi) DeletePushBasedLogConfiguration(ctx context.Context, groupId string) admin.DeletePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for DeletePushBasedLogConfiguration") + } + + var r0 admin.DeletePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeletePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.DeletePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePushBasedLogConfiguration' +type PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call struct { + *mock.Call +} + +// DeletePushBasedLogConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *PushBasedLogExportApi_Expecter) DeletePushBasedLogConfiguration(ctx interface{}, groupId interface{}) *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call { + return &PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call{Call: _e.mock.On("DeletePushBasedLogConfiguration", ctx, groupId)} +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call) Run(run func(ctx context.Context, groupId string)) *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call) Return(_a0 admin.DeletePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call) RunAndReturn(run func(context.Context, string) admin.DeletePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_DeletePushBasedLogConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeletePushBasedLogConfigurationExecute provides a mock function with given fields: r +func (_m *PushBasedLogExportApi) DeletePushBasedLogConfigurationExecute(r admin.DeletePushBasedLogConfigurationApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeletePushBasedLogConfigurationExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.DeletePushBasedLogConfigurationApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeletePushBasedLogConfigurationApiRequest) *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.DeletePushBasedLogConfigurationApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePushBasedLogConfigurationExecute' +type PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call struct { + *mock.Call +} + +// DeletePushBasedLogConfigurationExecute is a helper method to define mock.On call +// - r admin.DeletePushBasedLogConfigurationApiRequest +func (_e *PushBasedLogExportApi_Expecter) DeletePushBasedLogConfigurationExecute(r interface{}) *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call { + return &PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call{Call: _e.mock.On("DeletePushBasedLogConfigurationExecute", r)} +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call) Run(run func(r admin.DeletePushBasedLogConfigurationApiRequest)) *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeletePushBasedLogConfigurationApiRequest)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call) Return(_a0 *http.Response, _a1 error) *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call) RunAndReturn(run func(admin.DeletePushBasedLogConfigurationApiRequest) (*http.Response, error)) *PushBasedLogExportApi_DeletePushBasedLogConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeletePushBasedLogConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *PushBasedLogExportApi) DeletePushBasedLogConfigurationWithParams(ctx context.Context, args *admin.DeletePushBasedLogConfigurationApiParams) admin.DeletePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeletePushBasedLogConfigurationWithParams") + } + + var r0 admin.DeletePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeletePushBasedLogConfigurationApiParams) admin.DeletePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeletePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePushBasedLogConfigurationWithParams' +type PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call struct { + *mock.Call +} + +// DeletePushBasedLogConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeletePushBasedLogConfigurationApiParams +func (_e *PushBasedLogExportApi_Expecter) DeletePushBasedLogConfigurationWithParams(ctx interface{}, args interface{}) *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call { + return &PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call{Call: _e.mock.On("DeletePushBasedLogConfigurationWithParams", ctx, args)} +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeletePushBasedLogConfigurationApiParams)) *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeletePushBasedLogConfigurationApiParams)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call) Return(_a0 admin.DeletePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePushBasedLogConfigurationApiParams) admin.DeletePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_DeletePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetPushBasedLogConfiguration provides a mock function with given fields: ctx, groupId +func (_m *PushBasedLogExportApi) GetPushBasedLogConfiguration(ctx context.Context, groupId string) admin.GetPushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for GetPushBasedLogConfiguration") + } + + var r0 admin.GetPushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.GetPushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.GetPushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_GetPushBasedLogConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushBasedLogConfiguration' +type PushBasedLogExportApi_GetPushBasedLogConfiguration_Call struct { + *mock.Call +} + +// GetPushBasedLogConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *PushBasedLogExportApi_Expecter) GetPushBasedLogConfiguration(ctx interface{}, groupId interface{}) *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call { + return &PushBasedLogExportApi_GetPushBasedLogConfiguration_Call{Call: _e.mock.On("GetPushBasedLogConfiguration", ctx, groupId)} +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call) Run(run func(ctx context.Context, groupId string)) *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call) Return(_a0 admin.GetPushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call) RunAndReturn(run func(context.Context, string) admin.GetPushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_GetPushBasedLogConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetPushBasedLogConfigurationExecute provides a mock function with given fields: r +func (_m *PushBasedLogExportApi) GetPushBasedLogConfigurationExecute(r admin.GetPushBasedLogConfigurationApiRequest) (*admin.PushBasedLogExportProject, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetPushBasedLogConfigurationExecute") + } + + var r0 *admin.PushBasedLogExportProject + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetPushBasedLogConfigurationApiRequest) (*admin.PushBasedLogExportProject, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetPushBasedLogConfigurationApiRequest) *admin.PushBasedLogExportProject); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PushBasedLogExportProject) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetPushBasedLogConfigurationApiRequest) *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.GetPushBasedLogConfigurationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushBasedLogConfigurationExecute' +type PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call struct { + *mock.Call +} + +// GetPushBasedLogConfigurationExecute is a helper method to define mock.On call +// - r admin.GetPushBasedLogConfigurationApiRequest +func (_e *PushBasedLogExportApi_Expecter) GetPushBasedLogConfigurationExecute(r interface{}) *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call { + return &PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call{Call: _e.mock.On("GetPushBasedLogConfigurationExecute", r)} +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call) Run(run func(r admin.GetPushBasedLogConfigurationApiRequest)) *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetPushBasedLogConfigurationApiRequest)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call) Return(_a0 *admin.PushBasedLogExportProject, _a1 *http.Response, _a2 error) *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call) RunAndReturn(run func(admin.GetPushBasedLogConfigurationApiRequest) (*admin.PushBasedLogExportProject, *http.Response, error)) *PushBasedLogExportApi_GetPushBasedLogConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetPushBasedLogConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *PushBasedLogExportApi) GetPushBasedLogConfigurationWithParams(ctx context.Context, args *admin.GetPushBasedLogConfigurationApiParams) admin.GetPushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetPushBasedLogConfigurationWithParams") + } + + var r0 admin.GetPushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPushBasedLogConfigurationApiParams) admin.GetPushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetPushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushBasedLogConfigurationWithParams' +type PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call struct { + *mock.Call +} + +// GetPushBasedLogConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetPushBasedLogConfigurationApiParams +func (_e *PushBasedLogExportApi_Expecter) GetPushBasedLogConfigurationWithParams(ctx interface{}, args interface{}) *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call { + return &PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call{Call: _e.mock.On("GetPushBasedLogConfigurationWithParams", ctx, args)} +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPushBasedLogConfigurationApiParams)) *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetPushBasedLogConfigurationApiParams)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call) Return(_a0 admin.GetPushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPushBasedLogConfigurationApiParams) admin.GetPushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_GetPushBasedLogConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePushBasedLogConfiguration provides a mock function with given fields: ctx, groupId, pushBasedLogExportProject +func (_m *PushBasedLogExportApi) UpdatePushBasedLogConfiguration(ctx context.Context, groupId string, pushBasedLogExportProject *admin.PushBasedLogExportProject) admin.UpdatePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, groupId, pushBasedLogExportProject) + + if len(ret) == 0 { + panic("no return value specified for UpdatePushBasedLogConfiguration") + } + + var r0 admin.UpdatePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.PushBasedLogExportProject) admin.UpdatePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, groupId, pushBasedLogExportProject) + } else { + r0 = ret.Get(0).(admin.UpdatePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePushBasedLogConfiguration' +type PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call struct { + *mock.Call +} + +// UpdatePushBasedLogConfiguration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - pushBasedLogExportProject *admin.PushBasedLogExportProject +func (_e *PushBasedLogExportApi_Expecter) UpdatePushBasedLogConfiguration(ctx interface{}, groupId interface{}, pushBasedLogExportProject interface{}) *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call { + return &PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call{Call: _e.mock.On("UpdatePushBasedLogConfiguration", ctx, groupId, pushBasedLogExportProject)} +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call) Run(run func(ctx context.Context, groupId string, pushBasedLogExportProject *admin.PushBasedLogExportProject)) *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.PushBasedLogExportProject)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call) Return(_a0 admin.UpdatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call) RunAndReturn(run func(context.Context, string, *admin.PushBasedLogExportProject) admin.UpdatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_UpdatePushBasedLogConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePushBasedLogConfigurationExecute provides a mock function with given fields: r +func (_m *PushBasedLogExportApi) UpdatePushBasedLogConfigurationExecute(r admin.UpdatePushBasedLogConfigurationApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdatePushBasedLogConfigurationExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.UpdatePushBasedLogConfigurationApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdatePushBasedLogConfigurationApiRequest) *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.UpdatePushBasedLogConfigurationApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePushBasedLogConfigurationExecute' +type PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call struct { + *mock.Call +} + +// UpdatePushBasedLogConfigurationExecute is a helper method to define mock.On call +// - r admin.UpdatePushBasedLogConfigurationApiRequest +func (_e *PushBasedLogExportApi_Expecter) UpdatePushBasedLogConfigurationExecute(r interface{}) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call { + return &PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call{Call: _e.mock.On("UpdatePushBasedLogConfigurationExecute", r)} +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call) Run(run func(r admin.UpdatePushBasedLogConfigurationApiRequest)) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdatePushBasedLogConfigurationApiRequest)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call) Return(_a0 *http.Response, _a1 error) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call) RunAndReturn(run func(admin.UpdatePushBasedLogConfigurationApiRequest) (*http.Response, error)) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePushBasedLogConfigurationWithParams provides a mock function with given fields: ctx, args +func (_m *PushBasedLogExportApi) UpdatePushBasedLogConfigurationWithParams(ctx context.Context, args *admin.UpdatePushBasedLogConfigurationApiParams) admin.UpdatePushBasedLogConfigurationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdatePushBasedLogConfigurationWithParams") + } + + var r0 admin.UpdatePushBasedLogConfigurationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdatePushBasedLogConfigurationApiParams) admin.UpdatePushBasedLogConfigurationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdatePushBasedLogConfigurationApiRequest) + } + + return r0 +} + +// PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePushBasedLogConfigurationWithParams' +type PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call struct { + *mock.Call +} + +// UpdatePushBasedLogConfigurationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdatePushBasedLogConfigurationApiParams +func (_e *PushBasedLogExportApi_Expecter) UpdatePushBasedLogConfigurationWithParams(ctx interface{}, args interface{}) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call { + return &PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call{Call: _e.mock.On("UpdatePushBasedLogConfigurationWithParams", ctx, args)} +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdatePushBasedLogConfigurationApiParams)) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdatePushBasedLogConfigurationApiParams)) + }) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call) Return(_a0 admin.UpdatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdatePushBasedLogConfigurationApiParams) admin.UpdatePushBasedLogConfigurationApiRequest) *PushBasedLogExportApi_UpdatePushBasedLogConfigurationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewPushBasedLogExportApi creates a new instance of PushBasedLogExportApi. 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 NewPushBasedLogExportApi(t interface { + mock.TestingT + Cleanup(func()) +}) *PushBasedLogExportApi { + mock := &PushBasedLogExportApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/rolling_index_api.go b/mockadmin/rolling_index_api.go new file mode 100644 index 000000000..25b027161 --- /dev/null +++ b/mockadmin/rolling_index_api.go @@ -0,0 +1,194 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// RollingIndexApi is an autogenerated mock type for the RollingIndexApi type +type RollingIndexApi struct { + mock.Mock +} + +type RollingIndexApi_Expecter struct { + mock *mock.Mock +} + +func (_m *RollingIndexApi) EXPECT() *RollingIndexApi_Expecter { + return &RollingIndexApi_Expecter{mock: &_m.Mock} +} + +// CreateRollingIndex provides a mock function with given fields: ctx, groupId, clusterName, databaseRollingIndexRequest +func (_m *RollingIndexApi) CreateRollingIndex(ctx context.Context, groupId string, clusterName string, databaseRollingIndexRequest *admin.DatabaseRollingIndexRequest) admin.CreateRollingIndexApiRequest { + ret := _m.Called(ctx, groupId, clusterName, databaseRollingIndexRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateRollingIndex") + } + + var r0 admin.CreateRollingIndexApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DatabaseRollingIndexRequest) admin.CreateRollingIndexApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, databaseRollingIndexRequest) + } else { + r0 = ret.Get(0).(admin.CreateRollingIndexApiRequest) + } + + return r0 +} + +// RollingIndexApi_CreateRollingIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRollingIndex' +type RollingIndexApi_CreateRollingIndex_Call struct { + *mock.Call +} + +// CreateRollingIndex is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - databaseRollingIndexRequest *admin.DatabaseRollingIndexRequest +func (_e *RollingIndexApi_Expecter) CreateRollingIndex(ctx interface{}, groupId interface{}, clusterName interface{}, databaseRollingIndexRequest interface{}) *RollingIndexApi_CreateRollingIndex_Call { + return &RollingIndexApi_CreateRollingIndex_Call{Call: _e.mock.On("CreateRollingIndex", ctx, groupId, clusterName, databaseRollingIndexRequest)} +} + +func (_c *RollingIndexApi_CreateRollingIndex_Call) Run(run func(ctx context.Context, groupId string, clusterName string, databaseRollingIndexRequest *admin.DatabaseRollingIndexRequest)) *RollingIndexApi_CreateRollingIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DatabaseRollingIndexRequest)) + }) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndex_Call) Return(_a0 admin.CreateRollingIndexApiRequest) *RollingIndexApi_CreateRollingIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndex_Call) RunAndReturn(run func(context.Context, string, string, *admin.DatabaseRollingIndexRequest) admin.CreateRollingIndexApiRequest) *RollingIndexApi_CreateRollingIndex_Call { + _c.Call.Return(run) + return _c +} + +// CreateRollingIndexExecute provides a mock function with given fields: r +func (_m *RollingIndexApi) CreateRollingIndexExecute(r admin.CreateRollingIndexApiRequest) (*http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateRollingIndexExecute") + } + + var r0 *http.Response + var r1 error + if rf, ok := ret.Get(0).(func(admin.CreateRollingIndexApiRequest) (*http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateRollingIndexApiRequest) *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.CreateRollingIndexApiRequest) error); ok { + r1 = rf(r) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RollingIndexApi_CreateRollingIndexExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRollingIndexExecute' +type RollingIndexApi_CreateRollingIndexExecute_Call struct { + *mock.Call +} + +// CreateRollingIndexExecute is a helper method to define mock.On call +// - r admin.CreateRollingIndexApiRequest +func (_e *RollingIndexApi_Expecter) CreateRollingIndexExecute(r interface{}) *RollingIndexApi_CreateRollingIndexExecute_Call { + return &RollingIndexApi_CreateRollingIndexExecute_Call{Call: _e.mock.On("CreateRollingIndexExecute", r)} +} + +func (_c *RollingIndexApi_CreateRollingIndexExecute_Call) Run(run func(r admin.CreateRollingIndexApiRequest)) *RollingIndexApi_CreateRollingIndexExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateRollingIndexApiRequest)) + }) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndexExecute_Call) Return(_a0 *http.Response, _a1 error) *RollingIndexApi_CreateRollingIndexExecute_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndexExecute_Call) RunAndReturn(run func(admin.CreateRollingIndexApiRequest) (*http.Response, error)) *RollingIndexApi_CreateRollingIndexExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateRollingIndexWithParams provides a mock function with given fields: ctx, args +func (_m *RollingIndexApi) CreateRollingIndexWithParams(ctx context.Context, args *admin.CreateRollingIndexApiParams) admin.CreateRollingIndexApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateRollingIndexWithParams") + } + + var r0 admin.CreateRollingIndexApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateRollingIndexApiParams) admin.CreateRollingIndexApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateRollingIndexApiRequest) + } + + return r0 +} + +// RollingIndexApi_CreateRollingIndexWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRollingIndexWithParams' +type RollingIndexApi_CreateRollingIndexWithParams_Call struct { + *mock.Call +} + +// CreateRollingIndexWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateRollingIndexApiParams +func (_e *RollingIndexApi_Expecter) CreateRollingIndexWithParams(ctx interface{}, args interface{}) *RollingIndexApi_CreateRollingIndexWithParams_Call { + return &RollingIndexApi_CreateRollingIndexWithParams_Call{Call: _e.mock.On("CreateRollingIndexWithParams", ctx, args)} +} + +func (_c *RollingIndexApi_CreateRollingIndexWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateRollingIndexApiParams)) *RollingIndexApi_CreateRollingIndexWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateRollingIndexApiParams)) + }) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndexWithParams_Call) Return(_a0 admin.CreateRollingIndexApiRequest) *RollingIndexApi_CreateRollingIndexWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RollingIndexApi_CreateRollingIndexWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateRollingIndexApiParams) admin.CreateRollingIndexApiRequest) *RollingIndexApi_CreateRollingIndexWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewRollingIndexApi creates a new instance of RollingIndexApi. 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 NewRollingIndexApi(t interface { + mock.TestingT + Cleanup(func()) +}) *RollingIndexApi { + mock := &RollingIndexApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/root_api.go b/mockadmin/root_api.go new file mode 100644 index 000000000..3dd867984 --- /dev/null +++ b/mockadmin/root_api.go @@ -0,0 +1,360 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// RootApi is an autogenerated mock type for the RootApi type +type RootApi struct { + mock.Mock +} + +type RootApi_Expecter struct { + mock *mock.Mock +} + +func (_m *RootApi) EXPECT() *RootApi_Expecter { + return &RootApi_Expecter{mock: &_m.Mock} +} + +// GetSystemStatus provides a mock function with given fields: ctx +func (_m *RootApi) GetSystemStatus(ctx context.Context) admin.GetSystemStatusApiRequest { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetSystemStatus") + } + + var r0 admin.GetSystemStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context) admin.GetSystemStatusApiRequest); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(admin.GetSystemStatusApiRequest) + } + + return r0 +} + +// RootApi_GetSystemStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSystemStatus' +type RootApi_GetSystemStatus_Call struct { + *mock.Call +} + +// GetSystemStatus is a helper method to define mock.On call +// - ctx context.Context +func (_e *RootApi_Expecter) GetSystemStatus(ctx interface{}) *RootApi_GetSystemStatus_Call { + return &RootApi_GetSystemStatus_Call{Call: _e.mock.On("GetSystemStatus", ctx)} +} + +func (_c *RootApi_GetSystemStatus_Call) Run(run func(ctx context.Context)) *RootApi_GetSystemStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RootApi_GetSystemStatus_Call) Return(_a0 admin.GetSystemStatusApiRequest) *RootApi_GetSystemStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RootApi_GetSystemStatus_Call) RunAndReturn(run func(context.Context) admin.GetSystemStatusApiRequest) *RootApi_GetSystemStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetSystemStatusExecute provides a mock function with given fields: r +func (_m *RootApi) GetSystemStatusExecute(r admin.GetSystemStatusApiRequest) (*admin.SystemStatus, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetSystemStatusExecute") + } + + var r0 *admin.SystemStatus + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetSystemStatusApiRequest) (*admin.SystemStatus, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetSystemStatusApiRequest) *admin.SystemStatus); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.SystemStatus) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetSystemStatusApiRequest) *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.GetSystemStatusApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// RootApi_GetSystemStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSystemStatusExecute' +type RootApi_GetSystemStatusExecute_Call struct { + *mock.Call +} + +// GetSystemStatusExecute is a helper method to define mock.On call +// - r admin.GetSystemStatusApiRequest +func (_e *RootApi_Expecter) GetSystemStatusExecute(r interface{}) *RootApi_GetSystemStatusExecute_Call { + return &RootApi_GetSystemStatusExecute_Call{Call: _e.mock.On("GetSystemStatusExecute", r)} +} + +func (_c *RootApi_GetSystemStatusExecute_Call) Run(run func(r admin.GetSystemStatusApiRequest)) *RootApi_GetSystemStatusExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetSystemStatusApiRequest)) + }) + return _c +} + +func (_c *RootApi_GetSystemStatusExecute_Call) Return(_a0 *admin.SystemStatus, _a1 *http.Response, _a2 error) *RootApi_GetSystemStatusExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *RootApi_GetSystemStatusExecute_Call) RunAndReturn(run func(admin.GetSystemStatusApiRequest) (*admin.SystemStatus, *http.Response, error)) *RootApi_GetSystemStatusExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetSystemStatusWithParams provides a mock function with given fields: ctx, args +func (_m *RootApi) GetSystemStatusWithParams(ctx context.Context, args *admin.GetSystemStatusApiParams) admin.GetSystemStatusApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetSystemStatusWithParams") + } + + var r0 admin.GetSystemStatusApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetSystemStatusApiParams) admin.GetSystemStatusApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetSystemStatusApiRequest) + } + + return r0 +} + +// RootApi_GetSystemStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSystemStatusWithParams' +type RootApi_GetSystemStatusWithParams_Call struct { + *mock.Call +} + +// GetSystemStatusWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetSystemStatusApiParams +func (_e *RootApi_Expecter) GetSystemStatusWithParams(ctx interface{}, args interface{}) *RootApi_GetSystemStatusWithParams_Call { + return &RootApi_GetSystemStatusWithParams_Call{Call: _e.mock.On("GetSystemStatusWithParams", ctx, args)} +} + +func (_c *RootApi_GetSystemStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetSystemStatusApiParams)) *RootApi_GetSystemStatusWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetSystemStatusApiParams)) + }) + return _c +} + +func (_c *RootApi_GetSystemStatusWithParams_Call) Return(_a0 admin.GetSystemStatusApiRequest) *RootApi_GetSystemStatusWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RootApi_GetSystemStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetSystemStatusApiParams) admin.GetSystemStatusApiRequest) *RootApi_GetSystemStatusWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ReturnAllControlPlaneIPAddresses provides a mock function with given fields: ctx +func (_m *RootApi) ReturnAllControlPlaneIPAddresses(ctx context.Context) admin.ReturnAllControlPlaneIPAddressesApiRequest { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ReturnAllControlPlaneIPAddresses") + } + + var r0 admin.ReturnAllControlPlaneIPAddressesApiRequest + if rf, ok := ret.Get(0).(func(context.Context) admin.ReturnAllControlPlaneIPAddressesApiRequest); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(admin.ReturnAllControlPlaneIPAddressesApiRequest) + } + + return r0 +} + +// RootApi_ReturnAllControlPlaneIPAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllControlPlaneIPAddresses' +type RootApi_ReturnAllControlPlaneIPAddresses_Call struct { + *mock.Call +} + +// ReturnAllControlPlaneIPAddresses is a helper method to define mock.On call +// - ctx context.Context +func (_e *RootApi_Expecter) ReturnAllControlPlaneIPAddresses(ctx interface{}) *RootApi_ReturnAllControlPlaneIPAddresses_Call { + return &RootApi_ReturnAllControlPlaneIPAddresses_Call{Call: _e.mock.On("ReturnAllControlPlaneIPAddresses", ctx)} +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddresses_Call) Run(run func(ctx context.Context)) *RootApi_ReturnAllControlPlaneIPAddresses_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddresses_Call) Return(_a0 admin.ReturnAllControlPlaneIPAddressesApiRequest) *RootApi_ReturnAllControlPlaneIPAddresses_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddresses_Call) RunAndReturn(run func(context.Context) admin.ReturnAllControlPlaneIPAddressesApiRequest) *RootApi_ReturnAllControlPlaneIPAddresses_Call { + _c.Call.Return(run) + return _c +} + +// ReturnAllControlPlaneIPAddressesExecute provides a mock function with given fields: r +func (_m *RootApi) ReturnAllControlPlaneIPAddressesExecute(r admin.ReturnAllControlPlaneIPAddressesApiRequest) (*admin.ControlPlaneIPAddresses, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ReturnAllControlPlaneIPAddressesExecute") + } + + var r0 *admin.ControlPlaneIPAddresses + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ReturnAllControlPlaneIPAddressesApiRequest) (*admin.ControlPlaneIPAddresses, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ReturnAllControlPlaneIPAddressesApiRequest) *admin.ControlPlaneIPAddresses); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ControlPlaneIPAddresses) + } + } + + if rf, ok := ret.Get(1).(func(admin.ReturnAllControlPlaneIPAddressesApiRequest) *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.ReturnAllControlPlaneIPAddressesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// RootApi_ReturnAllControlPlaneIPAddressesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllControlPlaneIPAddressesExecute' +type RootApi_ReturnAllControlPlaneIPAddressesExecute_Call struct { + *mock.Call +} + +// ReturnAllControlPlaneIPAddressesExecute is a helper method to define mock.On call +// - r admin.ReturnAllControlPlaneIPAddressesApiRequest +func (_e *RootApi_Expecter) ReturnAllControlPlaneIPAddressesExecute(r interface{}) *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call { + return &RootApi_ReturnAllControlPlaneIPAddressesExecute_Call{Call: _e.mock.On("ReturnAllControlPlaneIPAddressesExecute", r)} +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call) Run(run func(r admin.ReturnAllControlPlaneIPAddressesApiRequest)) *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ReturnAllControlPlaneIPAddressesApiRequest)) + }) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call) Return(_a0 *admin.ControlPlaneIPAddresses, _a1 *http.Response, _a2 error) *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call) RunAndReturn(run func(admin.ReturnAllControlPlaneIPAddressesApiRequest) (*admin.ControlPlaneIPAddresses, *http.Response, error)) *RootApi_ReturnAllControlPlaneIPAddressesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ReturnAllControlPlaneIPAddressesWithParams provides a mock function with given fields: ctx, args +func (_m *RootApi) ReturnAllControlPlaneIPAddressesWithParams(ctx context.Context, args *admin.ReturnAllControlPlaneIPAddressesApiParams) admin.ReturnAllControlPlaneIPAddressesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ReturnAllControlPlaneIPAddressesWithParams") + } + + var r0 admin.ReturnAllControlPlaneIPAddressesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnAllControlPlaneIPAddressesApiParams) admin.ReturnAllControlPlaneIPAddressesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ReturnAllControlPlaneIPAddressesApiRequest) + } + + return r0 +} + +// RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReturnAllControlPlaneIPAddressesWithParams' +type RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call struct { + *mock.Call +} + +// ReturnAllControlPlaneIPAddressesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ReturnAllControlPlaneIPAddressesApiParams +func (_e *RootApi_Expecter) ReturnAllControlPlaneIPAddressesWithParams(ctx interface{}, args interface{}) *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call { + return &RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call{Call: _e.mock.On("ReturnAllControlPlaneIPAddressesWithParams", ctx, args)} +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnAllControlPlaneIPAddressesApiParams)) *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ReturnAllControlPlaneIPAddressesApiParams)) + }) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call) Return(_a0 admin.ReturnAllControlPlaneIPAddressesApiRequest) *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnAllControlPlaneIPAddressesApiParams) admin.ReturnAllControlPlaneIPAddressesApiRequest) *RootApi_ReturnAllControlPlaneIPAddressesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewRootApi creates a new instance of RootApi. 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 NewRootApi(t interface { + mock.TestingT + Cleanup(func()) +}) *RootApi { + mock := &RootApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/serverless_instances_api.go b/mockadmin/serverless_instances_api.go new file mode 100644 index 000000000..8216e20da --- /dev/null +++ b/mockadmin/serverless_instances_api.go @@ -0,0 +1,850 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ServerlessInstancesApi is an autogenerated mock type for the ServerlessInstancesApi type +type ServerlessInstancesApi struct { + mock.Mock +} + +type ServerlessInstancesApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ServerlessInstancesApi) EXPECT() *ServerlessInstancesApi_Expecter { + return &ServerlessInstancesApi_Expecter{mock: &_m.Mock} +} + +// CreateServerlessInstance provides a mock function with given fields: ctx, groupId, serverlessInstanceDescriptionCreate +func (_m *ServerlessInstancesApi) CreateServerlessInstance(ctx context.Context, groupId string, serverlessInstanceDescriptionCreate *admin.ServerlessInstanceDescriptionCreate) admin.CreateServerlessInstanceApiRequest { + ret := _m.Called(ctx, groupId, serverlessInstanceDescriptionCreate) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessInstance") + } + + var r0 admin.CreateServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.ServerlessInstanceDescriptionCreate) admin.CreateServerlessInstanceApiRequest); ok { + r0 = rf(ctx, groupId, serverlessInstanceDescriptionCreate) + } else { + r0 = ret.Get(0).(admin.CreateServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_CreateServerlessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessInstance' +type ServerlessInstancesApi_CreateServerlessInstance_Call struct { + *mock.Call +} + +// CreateServerlessInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - serverlessInstanceDescriptionCreate *admin.ServerlessInstanceDescriptionCreate +func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstance(ctx interface{}, groupId interface{}, serverlessInstanceDescriptionCreate interface{}) *ServerlessInstancesApi_CreateServerlessInstance_Call { + return &ServerlessInstancesApi_CreateServerlessInstance_Call{Call: _e.mock.On("CreateServerlessInstance", ctx, groupId, serverlessInstanceDescriptionCreate)} +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstance_Call) Run(run func(ctx context.Context, groupId string, serverlessInstanceDescriptionCreate *admin.ServerlessInstanceDescriptionCreate)) *ServerlessInstancesApi_CreateServerlessInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.ServerlessInstanceDescriptionCreate)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstance_Call) Return(_a0 admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstance_Call) RunAndReturn(run func(context.Context, string, *admin.ServerlessInstanceDescriptionCreate) admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstance_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessInstanceExecute provides a mock function with given fields: r +func (_m *ServerlessInstancesApi) CreateServerlessInstanceExecute(r admin.CreateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessInstanceExecute") + } + + var r0 *admin.ServerlessInstanceDescription + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateServerlessInstanceApiRequest) *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.CreateServerlessInstanceApiRequest) *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.CreateServerlessInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessInstancesApi_CreateServerlessInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessInstanceExecute' +type ServerlessInstancesApi_CreateServerlessInstanceExecute_Call struct { + *mock.Call +} + +// CreateServerlessInstanceExecute is a helper method to define mock.On call +// - r admin.CreateServerlessInstanceApiRequest +func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call { + return &ServerlessInstancesApi_CreateServerlessInstanceExecute_Call{Call: _e.mock.On("CreateServerlessInstanceExecute", r)} +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call) Run(run func(r admin.CreateServerlessInstanceApiRequest)) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateServerlessInstanceApiRequest)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call) Return(_a0 *admin.ServerlessInstanceDescription, _a1 *http.Response, _a2 error) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call) RunAndReturn(run func(admin.CreateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessInstancesApi) CreateServerlessInstanceWithParams(ctx context.Context, args *admin.CreateServerlessInstanceApiParams) admin.CreateServerlessInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessInstanceWithParams") + } + + var r0 admin.CreateServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateServerlessInstanceApiParams) admin.CreateServerlessInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessInstanceWithParams' +type ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call struct { + *mock.Call +} + +// CreateServerlessInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateServerlessInstanceApiParams +func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call { + return &ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call{Call: _e.mock.On("CreateServerlessInstanceWithParams", ctx, args)} +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateServerlessInstanceApiParams)) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateServerlessInstanceApiParams)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call) Return(_a0 admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateServerlessInstanceApiParams) admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessInstance provides a mock function with given fields: ctx, groupId, name +func (_m *ServerlessInstancesApi) DeleteServerlessInstance(ctx context.Context, groupId string, name string) admin.DeleteServerlessInstanceApiRequest { + ret := _m.Called(ctx, groupId, name) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessInstance") + } + + var r0 admin.DeleteServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteServerlessInstanceApiRequest); ok { + r0 = rf(ctx, groupId, name) + } else { + r0 = ret.Get(0).(admin.DeleteServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_DeleteServerlessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessInstance' +type ServerlessInstancesApi_DeleteServerlessInstance_Call struct { + *mock.Call +} + +// DeleteServerlessInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - name string +func (_e *ServerlessInstancesApi_Expecter) DeleteServerlessInstance(ctx interface{}, groupId interface{}, name interface{}) *ServerlessInstancesApi_DeleteServerlessInstance_Call { + return &ServerlessInstancesApi_DeleteServerlessInstance_Call{Call: _e.mock.On("DeleteServerlessInstance", ctx, groupId, name)} +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstance_Call) Run(run func(ctx context.Context, groupId string, name string)) *ServerlessInstancesApi_DeleteServerlessInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstance_Call) Return(_a0 admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstance_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstance_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessInstanceExecute provides a mock function with given fields: r +func (_m *ServerlessInstancesApi) DeleteServerlessInstanceExecute(r admin.DeleteServerlessInstanceApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessInstanceExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteServerlessInstanceApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteServerlessInstanceApiRequest) 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.DeleteServerlessInstanceApiRequest) *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.DeleteServerlessInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessInstanceExecute' +type ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call struct { + *mock.Call +} + +// DeleteServerlessInstanceExecute is a helper method to define mock.On call +// - r admin.DeleteServerlessInstanceApiRequest +func (_e *ServerlessInstancesApi_Expecter) DeleteServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call { + return &ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call{Call: _e.mock.On("DeleteServerlessInstanceExecute", r)} +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call) Run(run func(r admin.DeleteServerlessInstanceApiRequest)) *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteServerlessInstanceApiRequest)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call) RunAndReturn(run func(admin.DeleteServerlessInstanceApiRequest) (map[string]interface{}, *http.Response, error)) *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessInstancesApi) DeleteServerlessInstanceWithParams(ctx context.Context, args *admin.DeleteServerlessInstanceApiParams) admin.DeleteServerlessInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessInstanceWithParams") + } + + var r0 admin.DeleteServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteServerlessInstanceApiParams) admin.DeleteServerlessInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessInstanceWithParams' +type ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call struct { + *mock.Call +} + +// DeleteServerlessInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteServerlessInstanceApiParams +func (_e *ServerlessInstancesApi_Expecter) DeleteServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call { + return &ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call{Call: _e.mock.On("DeleteServerlessInstanceWithParams", ctx, args)} +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteServerlessInstanceApiParams)) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteServerlessInstanceApiParams)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call) Return(_a0 admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteServerlessInstanceApiParams) admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessInstance provides a mock function with given fields: ctx, groupId, name +func (_m *ServerlessInstancesApi) GetServerlessInstance(ctx context.Context, groupId string, name string) admin.GetServerlessInstanceApiRequest { + ret := _m.Called(ctx, groupId, name) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessInstance") + } + + var r0 admin.GetServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetServerlessInstanceApiRequest); ok { + r0 = rf(ctx, groupId, name) + } else { + r0 = ret.Get(0).(admin.GetServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_GetServerlessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessInstance' +type ServerlessInstancesApi_GetServerlessInstance_Call struct { + *mock.Call +} + +// GetServerlessInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - name string +func (_e *ServerlessInstancesApi_Expecter) GetServerlessInstance(ctx interface{}, groupId interface{}, name interface{}) *ServerlessInstancesApi_GetServerlessInstance_Call { + return &ServerlessInstancesApi_GetServerlessInstance_Call{Call: _e.mock.On("GetServerlessInstance", ctx, groupId, name)} +} + +func (_c *ServerlessInstancesApi_GetServerlessInstance_Call) Run(run func(ctx context.Context, groupId string, name string)) *ServerlessInstancesApi_GetServerlessInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstance_Call) Return(_a0 admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstance_Call) RunAndReturn(run func(context.Context, string, string) admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstance_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessInstanceExecute provides a mock function with given fields: r +func (_m *ServerlessInstancesApi) GetServerlessInstanceExecute(r admin.GetServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessInstanceExecute") + } + + var r0 *admin.ServerlessInstanceDescription + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetServerlessInstanceApiRequest) *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.GetServerlessInstanceApiRequest) *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.GetServerlessInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessInstancesApi_GetServerlessInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessInstanceExecute' +type ServerlessInstancesApi_GetServerlessInstanceExecute_Call struct { + *mock.Call +} + +// GetServerlessInstanceExecute is a helper method to define mock.On call +// - r admin.GetServerlessInstanceApiRequest +func (_e *ServerlessInstancesApi_Expecter) GetServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call { + return &ServerlessInstancesApi_GetServerlessInstanceExecute_Call{Call: _e.mock.On("GetServerlessInstanceExecute", r)} +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceExecute_Call) Run(run func(r admin.GetServerlessInstanceApiRequest)) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetServerlessInstanceApiRequest)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceExecute_Call) Return(_a0 *admin.ServerlessInstanceDescription, _a1 *http.Response, _a2 error) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceExecute_Call) RunAndReturn(run func(admin.GetServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessInstancesApi) GetServerlessInstanceWithParams(ctx context.Context, args *admin.GetServerlessInstanceApiParams) admin.GetServerlessInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessInstanceWithParams") + } + + var r0 admin.GetServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessInstanceApiParams) admin.GetServerlessInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_GetServerlessInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessInstanceWithParams' +type ServerlessInstancesApi_GetServerlessInstanceWithParams_Call struct { + *mock.Call +} + +// GetServerlessInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetServerlessInstanceApiParams +func (_e *ServerlessInstancesApi_Expecter) GetServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call { + return &ServerlessInstancesApi_GetServerlessInstanceWithParams_Call{Call: _e.mock.On("GetServerlessInstanceWithParams", ctx, args)} +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessInstanceApiParams)) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetServerlessInstanceApiParams)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call) Return(_a0 admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessInstanceApiParams) admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessInstances provides a mock function with given fields: ctx, groupId +func (_m *ServerlessInstancesApi) ListServerlessInstances(ctx context.Context, groupId string) admin.ListServerlessInstancesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessInstances") + } + + var r0 admin.ListServerlessInstancesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListServerlessInstancesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListServerlessInstancesApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_ListServerlessInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessInstances' +type ServerlessInstancesApi_ListServerlessInstances_Call struct { + *mock.Call +} + +// ListServerlessInstances is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *ServerlessInstancesApi_Expecter) ListServerlessInstances(ctx interface{}, groupId interface{}) *ServerlessInstancesApi_ListServerlessInstances_Call { + return &ServerlessInstancesApi_ListServerlessInstances_Call{Call: _e.mock.On("ListServerlessInstances", ctx, groupId)} +} + +func (_c *ServerlessInstancesApi_ListServerlessInstances_Call) Run(run func(ctx context.Context, groupId string)) *ServerlessInstancesApi_ListServerlessInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstances_Call) Return(_a0 admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstances_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstances_Call) RunAndReturn(run func(context.Context, string) admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstances_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessInstancesExecute provides a mock function with given fields: r +func (_m *ServerlessInstancesApi) ListServerlessInstancesExecute(r admin.ListServerlessInstancesApiRequest) (*admin.PaginatedServerlessInstanceDescription, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessInstancesExecute") + } + + var r0 *admin.PaginatedServerlessInstanceDescription + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListServerlessInstancesApiRequest) (*admin.PaginatedServerlessInstanceDescription, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListServerlessInstancesApiRequest) *admin.PaginatedServerlessInstanceDescription); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedServerlessInstanceDescription) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListServerlessInstancesApiRequest) *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.ListServerlessInstancesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessInstancesApi_ListServerlessInstancesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessInstancesExecute' +type ServerlessInstancesApi_ListServerlessInstancesExecute_Call struct { + *mock.Call +} + +// ListServerlessInstancesExecute is a helper method to define mock.On call +// - r admin.ListServerlessInstancesApiRequest +func (_e *ServerlessInstancesApi_Expecter) ListServerlessInstancesExecute(r interface{}) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call { + return &ServerlessInstancesApi_ListServerlessInstancesExecute_Call{Call: _e.mock.On("ListServerlessInstancesExecute", r)} +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesExecute_Call) Run(run func(r admin.ListServerlessInstancesApiRequest)) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListServerlessInstancesApiRequest)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesExecute_Call) Return(_a0 *admin.PaginatedServerlessInstanceDescription, _a1 *http.Response, _a2 error) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesExecute_Call) RunAndReturn(run func(admin.ListServerlessInstancesApiRequest) (*admin.PaginatedServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessInstancesWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessInstancesApi) ListServerlessInstancesWithParams(ctx context.Context, args *admin.ListServerlessInstancesApiParams) admin.ListServerlessInstancesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessInstancesWithParams") + } + + var r0 admin.ListServerlessInstancesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListServerlessInstancesApiParams) admin.ListServerlessInstancesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListServerlessInstancesApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_ListServerlessInstancesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessInstancesWithParams' +type ServerlessInstancesApi_ListServerlessInstancesWithParams_Call struct { + *mock.Call +} + +// ListServerlessInstancesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListServerlessInstancesApiParams +func (_e *ServerlessInstancesApi_Expecter) ListServerlessInstancesWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call { + return &ServerlessInstancesApi_ListServerlessInstancesWithParams_Call{Call: _e.mock.On("ListServerlessInstancesWithParams", ctx, args)} +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListServerlessInstancesApiParams)) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListServerlessInstancesApiParams)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call) Return(_a0 admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessInstancesApiParams) admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessInstance provides a mock function with given fields: ctx, groupId, name, serverlessInstanceDescriptionUpdate +func (_m *ServerlessInstancesApi) UpdateServerlessInstance(ctx context.Context, groupId string, name string, serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate) admin.UpdateServerlessInstanceApiRequest { + ret := _m.Called(ctx, groupId, name, serverlessInstanceDescriptionUpdate) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessInstance") + } + + var r0 admin.UpdateServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ServerlessInstanceDescriptionUpdate) admin.UpdateServerlessInstanceApiRequest); ok { + r0 = rf(ctx, groupId, name, serverlessInstanceDescriptionUpdate) + } else { + r0 = ret.Get(0).(admin.UpdateServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_UpdateServerlessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessInstance' +type ServerlessInstancesApi_UpdateServerlessInstance_Call struct { + *mock.Call +} + +// UpdateServerlessInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - name string +// - serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate +func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstance(ctx interface{}, groupId interface{}, name interface{}, serverlessInstanceDescriptionUpdate interface{}) *ServerlessInstancesApi_UpdateServerlessInstance_Call { + return &ServerlessInstancesApi_UpdateServerlessInstance_Call{Call: _e.mock.On("UpdateServerlessInstance", ctx, groupId, name, serverlessInstanceDescriptionUpdate)} +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) Run(run func(ctx context.Context, groupId string, name string, serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate)) *ServerlessInstancesApi_UpdateServerlessInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ServerlessInstanceDescriptionUpdate)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) Return(_a0 admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) RunAndReturn(run func(context.Context, string, string, *admin.ServerlessInstanceDescriptionUpdate) admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstance_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessInstanceExecute provides a mock function with given fields: r +func (_m *ServerlessInstancesApi) UpdateServerlessInstanceExecute(r admin.UpdateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessInstanceExecute") + } + + var r0 *admin.ServerlessInstanceDescription + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateServerlessInstanceApiRequest) *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.UpdateServerlessInstanceApiRequest) *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.UpdateServerlessInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessInstanceExecute' +type ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call struct { + *mock.Call +} + +// UpdateServerlessInstanceExecute is a helper method to define mock.On call +// - r admin.UpdateServerlessInstanceApiRequest +func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call { + return &ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call{Call: _e.mock.On("UpdateServerlessInstanceExecute", r)} +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call) Run(run func(r admin.UpdateServerlessInstanceApiRequest)) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateServerlessInstanceApiRequest)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call) Return(_a0 *admin.ServerlessInstanceDescription, _a1 *http.Response, _a2 error) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call) RunAndReturn(run func(admin.UpdateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessInstancesApi) UpdateServerlessInstanceWithParams(ctx context.Context, args *admin.UpdateServerlessInstanceApiParams) admin.UpdateServerlessInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessInstanceWithParams") + } + + var r0 admin.UpdateServerlessInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateServerlessInstanceApiParams) admin.UpdateServerlessInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateServerlessInstanceApiRequest) + } + + return r0 +} + +// ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessInstanceWithParams' +type ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call struct { + *mock.Call +} + +// UpdateServerlessInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateServerlessInstanceApiParams +func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call { + return &ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call{Call: _e.mock.On("UpdateServerlessInstanceWithParams", ctx, args)} +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateServerlessInstanceApiParams)) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateServerlessInstanceApiParams)) + }) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call) Return(_a0 admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateServerlessInstanceApiParams) admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewServerlessInstancesApi creates a new instance of ServerlessInstancesApi. 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 NewServerlessInstancesApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ServerlessInstancesApi { + mock := &ServerlessInstancesApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/serverless_private_endpoints_api.go b/mockadmin/serverless_private_endpoints_api.go new file mode 100644 index 000000000..153938efb --- /dev/null +++ b/mockadmin/serverless_private_endpoints_api.go @@ -0,0 +1,855 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ServerlessPrivateEndpointsApi is an autogenerated mock type for the ServerlessPrivateEndpointsApi type +type ServerlessPrivateEndpointsApi struct { + mock.Mock +} + +type ServerlessPrivateEndpointsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ServerlessPrivateEndpointsApi) EXPECT() *ServerlessPrivateEndpointsApi_Expecter { + return &ServerlessPrivateEndpointsApi_Expecter{mock: &_m.Mock} +} + +// CreateServerlessPrivateEndpoint provides a mock function with given fields: ctx, groupId, instanceName, serverlessTenantCreateRequest +func (_m *ServerlessPrivateEndpointsApi) CreateServerlessPrivateEndpoint(ctx context.Context, groupId string, instanceName string, serverlessTenantCreateRequest *admin.ServerlessTenantCreateRequest) admin.CreateServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, instanceName, serverlessTenantCreateRequest) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessPrivateEndpoint") + } + + var r0 admin.CreateServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ServerlessTenantCreateRequest) admin.CreateServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, instanceName, serverlessTenantCreateRequest) + } else { + r0 = ret.Get(0).(admin.CreateServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessPrivateEndpoint' +type ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call struct { + *mock.Call +} + +// CreateServerlessPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - instanceName string +// - serverlessTenantCreateRequest *admin.ServerlessTenantCreateRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) CreateServerlessPrivateEndpoint(ctx interface{}, groupId interface{}, instanceName interface{}, serverlessTenantCreateRequest interface{}) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call { + return &ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call{Call: _e.mock.On("CreateServerlessPrivateEndpoint", ctx, groupId, instanceName, serverlessTenantCreateRequest)} +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, instanceName string, serverlessTenantCreateRequest *admin.ServerlessTenantCreateRequest)) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ServerlessTenantCreateRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call) Return(_a0 admin.CreateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, *admin.ServerlessTenantCreateRequest) admin.CreateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessPrivateEndpointExecute provides a mock function with given fields: r +func (_m *ServerlessPrivateEndpointsApi) CreateServerlessPrivateEndpointExecute(r admin.CreateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessPrivateEndpointExecute") + } + + var r0 *admin.ServerlessTenantEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateServerlessPrivateEndpointApiRequest) *admin.ServerlessTenantEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessTenantEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateServerlessPrivateEndpointApiRequest) *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.CreateServerlessPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessPrivateEndpointExecute' +type ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call struct { + *mock.Call +} + +// CreateServerlessPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.CreateServerlessPrivateEndpointApiRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) CreateServerlessPrivateEndpointExecute(r interface{}) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call { + return &ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call{Call: _e.mock.On("CreateServerlessPrivateEndpointExecute", r)} +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call) Run(run func(r admin.CreateServerlessPrivateEndpointApiRequest)) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateServerlessPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call) Return(_a0 *admin.ServerlessTenantEndpoint, _a1 *http.Response, _a2 error) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call) RunAndReturn(run func(admin.CreateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateServerlessPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessPrivateEndpointsApi) CreateServerlessPrivateEndpointWithParams(ctx context.Context, args *admin.CreateServerlessPrivateEndpointApiParams) admin.CreateServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateServerlessPrivateEndpointWithParams") + } + + var r0 admin.CreateServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateServerlessPrivateEndpointApiParams) admin.CreateServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServerlessPrivateEndpointWithParams' +type ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// CreateServerlessPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateServerlessPrivateEndpointApiParams +func (_e *ServerlessPrivateEndpointsApi_Expecter) CreateServerlessPrivateEndpointWithParams(ctx interface{}, args interface{}) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call { + return &ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call{Call: _e.mock.On("CreateServerlessPrivateEndpointWithParams", ctx, args)} +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateServerlessPrivateEndpointApiParams)) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateServerlessPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call) Return(_a0 admin.CreateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateServerlessPrivateEndpointApiParams) admin.CreateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_CreateServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessPrivateEndpoint provides a mock function with given fields: ctx, groupId, instanceName, endpointId +func (_m *ServerlessPrivateEndpointsApi) DeleteServerlessPrivateEndpoint(ctx context.Context, groupId string, instanceName string, endpointId string) admin.DeleteServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, instanceName, endpointId) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessPrivateEndpoint") + } + + var r0 admin.DeleteServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, instanceName, endpointId) + } else { + r0 = ret.Get(0).(admin.DeleteServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessPrivateEndpoint' +type ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call struct { + *mock.Call +} + +// DeleteServerlessPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - instanceName string +// - endpointId string +func (_e *ServerlessPrivateEndpointsApi_Expecter) DeleteServerlessPrivateEndpoint(ctx interface{}, groupId interface{}, instanceName interface{}, endpointId interface{}) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call { + return &ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call{Call: _e.mock.On("DeleteServerlessPrivateEndpoint", ctx, groupId, instanceName, endpointId)} +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, instanceName string, endpointId string)) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_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 *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call) Return(_a0 admin.DeleteServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessPrivateEndpointExecute provides a mock function with given fields: r +func (_m *ServerlessPrivateEndpointsApi) DeleteServerlessPrivateEndpointExecute(r admin.DeleteServerlessPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessPrivateEndpointExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteServerlessPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteServerlessPrivateEndpointApiRequest) 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.DeleteServerlessPrivateEndpointApiRequest) *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.DeleteServerlessPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessPrivateEndpointExecute' +type ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call struct { + *mock.Call +} + +// DeleteServerlessPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.DeleteServerlessPrivateEndpointApiRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) DeleteServerlessPrivateEndpointExecute(r interface{}) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call { + return &ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call{Call: _e.mock.On("DeleteServerlessPrivateEndpointExecute", r)} +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call) Run(run func(r admin.DeleteServerlessPrivateEndpointApiRequest)) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteServerlessPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call) RunAndReturn(run func(admin.DeleteServerlessPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteServerlessPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessPrivateEndpointsApi) DeleteServerlessPrivateEndpointWithParams(ctx context.Context, args *admin.DeleteServerlessPrivateEndpointApiParams) admin.DeleteServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteServerlessPrivateEndpointWithParams") + } + + var r0 admin.DeleteServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteServerlessPrivateEndpointApiParams) admin.DeleteServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServerlessPrivateEndpointWithParams' +type ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// DeleteServerlessPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteServerlessPrivateEndpointApiParams +func (_e *ServerlessPrivateEndpointsApi_Expecter) DeleteServerlessPrivateEndpointWithParams(ctx interface{}, args interface{}) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call { + return &ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call{Call: _e.mock.On("DeleteServerlessPrivateEndpointWithParams", ctx, args)} +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteServerlessPrivateEndpointApiParams)) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteServerlessPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call) Return(_a0 admin.DeleteServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteServerlessPrivateEndpointApiParams) admin.DeleteServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_DeleteServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessPrivateEndpoint provides a mock function with given fields: ctx, groupId, instanceName, endpointId +func (_m *ServerlessPrivateEndpointsApi) GetServerlessPrivateEndpoint(ctx context.Context, groupId string, instanceName string, endpointId string) admin.GetServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, instanceName, endpointId) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessPrivateEndpoint") + } + + var r0 admin.GetServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, instanceName, endpointId) + } else { + r0 = ret.Get(0).(admin.GetServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessPrivateEndpoint' +type ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call struct { + *mock.Call +} + +// GetServerlessPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - instanceName string +// - endpointId string +func (_e *ServerlessPrivateEndpointsApi_Expecter) GetServerlessPrivateEndpoint(ctx interface{}, groupId interface{}, instanceName interface{}, endpointId interface{}) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call { + return &ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call{Call: _e.mock.On("GetServerlessPrivateEndpoint", ctx, groupId, instanceName, endpointId)} +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, instanceName string, endpointId string)) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_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 *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call) Return(_a0 admin.GetServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessPrivateEndpointExecute provides a mock function with given fields: r +func (_m *ServerlessPrivateEndpointsApi) GetServerlessPrivateEndpointExecute(r admin.GetServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessPrivateEndpointExecute") + } + + var r0 *admin.ServerlessTenantEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetServerlessPrivateEndpointApiRequest) *admin.ServerlessTenantEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessTenantEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetServerlessPrivateEndpointApiRequest) *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.GetServerlessPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessPrivateEndpointExecute' +type ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call struct { + *mock.Call +} + +// GetServerlessPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.GetServerlessPrivateEndpointApiRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) GetServerlessPrivateEndpointExecute(r interface{}) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call { + return &ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call{Call: _e.mock.On("GetServerlessPrivateEndpointExecute", r)} +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call) Run(run func(r admin.GetServerlessPrivateEndpointApiRequest)) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetServerlessPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call) Return(_a0 *admin.ServerlessTenantEndpoint, _a1 *http.Response, _a2 error) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call) RunAndReturn(run func(admin.GetServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetServerlessPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessPrivateEndpointsApi) GetServerlessPrivateEndpointWithParams(ctx context.Context, args *admin.GetServerlessPrivateEndpointApiParams) admin.GetServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetServerlessPrivateEndpointWithParams") + } + + var r0 admin.GetServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetServerlessPrivateEndpointApiParams) admin.GetServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerlessPrivateEndpointWithParams' +type ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// GetServerlessPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetServerlessPrivateEndpointApiParams +func (_e *ServerlessPrivateEndpointsApi_Expecter) GetServerlessPrivateEndpointWithParams(ctx interface{}, args interface{}) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call { + return &ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call{Call: _e.mock.On("GetServerlessPrivateEndpointWithParams", ctx, args)} +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.GetServerlessPrivateEndpointApiParams)) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetServerlessPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call) Return(_a0 admin.GetServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessPrivateEndpointApiParams) admin.GetServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_GetServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessPrivateEndpoints provides a mock function with given fields: ctx, groupId, instanceName +func (_m *ServerlessPrivateEndpointsApi) ListServerlessPrivateEndpoints(ctx context.Context, groupId string, instanceName string) admin.ListServerlessPrivateEndpointsApiRequest { + ret := _m.Called(ctx, groupId, instanceName) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessPrivateEndpoints") + } + + var r0 admin.ListServerlessPrivateEndpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListServerlessPrivateEndpointsApiRequest); ok { + r0 = rf(ctx, groupId, instanceName) + } else { + r0 = ret.Get(0).(admin.ListServerlessPrivateEndpointsApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessPrivateEndpoints' +type ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call struct { + *mock.Call +} + +// ListServerlessPrivateEndpoints is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - instanceName string +func (_e *ServerlessPrivateEndpointsApi_Expecter) ListServerlessPrivateEndpoints(ctx interface{}, groupId interface{}, instanceName interface{}) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call { + return &ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call{Call: _e.mock.On("ListServerlessPrivateEndpoints", ctx, groupId, instanceName)} +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call) Run(run func(ctx context.Context, groupId string, instanceName string)) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call) Return(_a0 admin.ListServerlessPrivateEndpointsApiRequest) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call) RunAndReturn(run func(context.Context, string, string) admin.ListServerlessPrivateEndpointsApiRequest) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpoints_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessPrivateEndpointsExecute provides a mock function with given fields: r +func (_m *ServerlessPrivateEndpointsApi) ListServerlessPrivateEndpointsExecute(r admin.ListServerlessPrivateEndpointsApiRequest) ([]admin.ServerlessTenantEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessPrivateEndpointsExecute") + } + + var r0 []admin.ServerlessTenantEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListServerlessPrivateEndpointsApiRequest) ([]admin.ServerlessTenantEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListServerlessPrivateEndpointsApiRequest) []admin.ServerlessTenantEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]admin.ServerlessTenantEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListServerlessPrivateEndpointsApiRequest) *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.ListServerlessPrivateEndpointsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessPrivateEndpointsExecute' +type ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call struct { + *mock.Call +} + +// ListServerlessPrivateEndpointsExecute is a helper method to define mock.On call +// - r admin.ListServerlessPrivateEndpointsApiRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) ListServerlessPrivateEndpointsExecute(r interface{}) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call { + return &ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call{Call: _e.mock.On("ListServerlessPrivateEndpointsExecute", r)} +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call) Run(run func(r admin.ListServerlessPrivateEndpointsApiRequest)) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListServerlessPrivateEndpointsApiRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call) Return(_a0 []admin.ServerlessTenantEndpoint, _a1 *http.Response, _a2 error) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call) RunAndReturn(run func(admin.ListServerlessPrivateEndpointsApiRequest) ([]admin.ServerlessTenantEndpoint, *http.Response, error)) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListServerlessPrivateEndpointsWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessPrivateEndpointsApi) ListServerlessPrivateEndpointsWithParams(ctx context.Context, args *admin.ListServerlessPrivateEndpointsApiParams) admin.ListServerlessPrivateEndpointsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListServerlessPrivateEndpointsWithParams") + } + + var r0 admin.ListServerlessPrivateEndpointsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListServerlessPrivateEndpointsApiParams) admin.ListServerlessPrivateEndpointsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListServerlessPrivateEndpointsApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListServerlessPrivateEndpointsWithParams' +type ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call struct { + *mock.Call +} + +// ListServerlessPrivateEndpointsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListServerlessPrivateEndpointsApiParams +func (_e *ServerlessPrivateEndpointsApi_Expecter) ListServerlessPrivateEndpointsWithParams(ctx interface{}, args interface{}) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call { + return &ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call{Call: _e.mock.On("ListServerlessPrivateEndpointsWithParams", ctx, args)} +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListServerlessPrivateEndpointsApiParams)) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListServerlessPrivateEndpointsApiParams)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call) Return(_a0 admin.ListServerlessPrivateEndpointsApiRequest) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessPrivateEndpointsApiParams) admin.ListServerlessPrivateEndpointsApiRequest) *ServerlessPrivateEndpointsApi_ListServerlessPrivateEndpointsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessPrivateEndpoint provides a mock function with given fields: ctx, groupId, instanceName, endpointId, serverlessTenantEndpointUpdate +func (_m *ServerlessPrivateEndpointsApi) UpdateServerlessPrivateEndpoint(ctx context.Context, groupId string, instanceName string, endpointId string, serverlessTenantEndpointUpdate *admin.ServerlessTenantEndpointUpdate) admin.UpdateServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, groupId, instanceName, endpointId, serverlessTenantEndpointUpdate) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessPrivateEndpoint") + } + + var r0 admin.UpdateServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.ServerlessTenantEndpointUpdate) admin.UpdateServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, groupId, instanceName, endpointId, serverlessTenantEndpointUpdate) + } else { + r0 = ret.Get(0).(admin.UpdateServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessPrivateEndpoint' +type ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call struct { + *mock.Call +} + +// UpdateServerlessPrivateEndpoint is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - instanceName string +// - endpointId string +// - serverlessTenantEndpointUpdate *admin.ServerlessTenantEndpointUpdate +func (_e *ServerlessPrivateEndpointsApi_Expecter) UpdateServerlessPrivateEndpoint(ctx interface{}, groupId interface{}, instanceName interface{}, endpointId interface{}, serverlessTenantEndpointUpdate interface{}) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call { + return &ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call{Call: _e.mock.On("UpdateServerlessPrivateEndpoint", ctx, groupId, instanceName, endpointId, serverlessTenantEndpointUpdate)} +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, instanceName string, endpointId string, serverlessTenantEndpointUpdate *admin.ServerlessTenantEndpointUpdate)) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_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.ServerlessTenantEndpointUpdate)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call) Return(_a0 admin.UpdateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.ServerlessTenantEndpointUpdate) admin.UpdateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpoint_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessPrivateEndpointExecute provides a mock function with given fields: r +func (_m *ServerlessPrivateEndpointsApi) UpdateServerlessPrivateEndpointExecute(r admin.UpdateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessPrivateEndpointExecute") + } + + var r0 *admin.ServerlessTenantEndpoint + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateServerlessPrivateEndpointApiRequest) *admin.ServerlessTenantEndpoint); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ServerlessTenantEndpoint) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateServerlessPrivateEndpointApiRequest) *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.UpdateServerlessPrivateEndpointApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessPrivateEndpointExecute' +type ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call struct { + *mock.Call +} + +// UpdateServerlessPrivateEndpointExecute is a helper method to define mock.On call +// - r admin.UpdateServerlessPrivateEndpointApiRequest +func (_e *ServerlessPrivateEndpointsApi_Expecter) UpdateServerlessPrivateEndpointExecute(r interface{}) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call { + return &ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call{Call: _e.mock.On("UpdateServerlessPrivateEndpointExecute", r)} +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call) Run(run func(r admin.UpdateServerlessPrivateEndpointApiRequest)) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateServerlessPrivateEndpointApiRequest)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call) Return(_a0 *admin.ServerlessTenantEndpoint, _a1 *http.Response, _a2 error) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call) RunAndReturn(run func(admin.UpdateServerlessPrivateEndpointApiRequest) (*admin.ServerlessTenantEndpoint, *http.Response, error)) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateServerlessPrivateEndpointWithParams provides a mock function with given fields: ctx, args +func (_m *ServerlessPrivateEndpointsApi) UpdateServerlessPrivateEndpointWithParams(ctx context.Context, args *admin.UpdateServerlessPrivateEndpointApiParams) admin.UpdateServerlessPrivateEndpointApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateServerlessPrivateEndpointWithParams") + } + + var r0 admin.UpdateServerlessPrivateEndpointApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateServerlessPrivateEndpointApiParams) admin.UpdateServerlessPrivateEndpointApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateServerlessPrivateEndpointApiRequest) + } + + return r0 +} + +// ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateServerlessPrivateEndpointWithParams' +type ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call struct { + *mock.Call +} + +// UpdateServerlessPrivateEndpointWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateServerlessPrivateEndpointApiParams +func (_e *ServerlessPrivateEndpointsApi_Expecter) UpdateServerlessPrivateEndpointWithParams(ctx interface{}, args interface{}) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call { + return &ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call{Call: _e.mock.On("UpdateServerlessPrivateEndpointWithParams", ctx, args)} +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateServerlessPrivateEndpointApiParams)) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateServerlessPrivateEndpointApiParams)) + }) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call) Return(_a0 admin.UpdateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateServerlessPrivateEndpointApiParams) admin.UpdateServerlessPrivateEndpointApiRequest) *ServerlessPrivateEndpointsApi_UpdateServerlessPrivateEndpointWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewServerlessPrivateEndpointsApi creates a new instance of ServerlessPrivateEndpointsApi. 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 NewServerlessPrivateEndpointsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ServerlessPrivateEndpointsApi { + mock := &ServerlessPrivateEndpointsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/shared_tier_restore_jobs_api.go b/mockadmin/shared_tier_restore_jobs_api.go new file mode 100644 index 000000000..313fea2d4 --- /dev/null +++ b/mockadmin/shared_tier_restore_jobs_api.go @@ -0,0 +1,528 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// SharedTierRestoreJobsApi is an autogenerated mock type for the SharedTierRestoreJobsApi type +type SharedTierRestoreJobsApi struct { + mock.Mock +} + +type SharedTierRestoreJobsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *SharedTierRestoreJobsApi) EXPECT() *SharedTierRestoreJobsApi_Expecter { + return &SharedTierRestoreJobsApi_Expecter{mock: &_m.Mock} +} + +// CreateSharedClusterBackupRestoreJob provides a mock function with given fields: ctx, clusterName, groupId, tenantRestore +func (_m *SharedTierRestoreJobsApi) CreateSharedClusterBackupRestoreJob(ctx context.Context, clusterName string, groupId string, tenantRestore *admin.TenantRestore) admin.CreateSharedClusterBackupRestoreJobApiRequest { + ret := _m.Called(ctx, clusterName, groupId, tenantRestore) + + if len(ret) == 0 { + panic("no return value specified for CreateSharedClusterBackupRestoreJob") + } + + var r0 admin.CreateSharedClusterBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TenantRestore) admin.CreateSharedClusterBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, clusterName, groupId, tenantRestore) + } else { + r0 = ret.Get(0).(admin.CreateSharedClusterBackupRestoreJobApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSharedClusterBackupRestoreJob' +type SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call struct { + *mock.Call +} + +// CreateSharedClusterBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - groupId string +// - tenantRestore *admin.TenantRestore +func (_e *SharedTierRestoreJobsApi_Expecter) CreateSharedClusterBackupRestoreJob(ctx interface{}, clusterName interface{}, groupId interface{}, tenantRestore interface{}) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call { + return &SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call{Call: _e.mock.On("CreateSharedClusterBackupRestoreJob", ctx, clusterName, groupId, tenantRestore)} +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call) Run(run func(ctx context.Context, clusterName string, groupId string, tenantRestore *admin.TenantRestore)) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TenantRestore)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call) Return(_a0 admin.CreateSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.TenantRestore) admin.CreateSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// CreateSharedClusterBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *SharedTierRestoreJobsApi) CreateSharedClusterBackupRestoreJobExecute(r admin.CreateSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateSharedClusterBackupRestoreJobExecute") + } + + var r0 *admin.TenantRestore + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateSharedClusterBackupRestoreJobApiRequest) *admin.TenantRestore); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.TenantRestore) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateSharedClusterBackupRestoreJobApiRequest) *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.CreateSharedClusterBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSharedClusterBackupRestoreJobExecute' +type SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// CreateSharedClusterBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.CreateSharedClusterBackupRestoreJobApiRequest +func (_e *SharedTierRestoreJobsApi_Expecter) CreateSharedClusterBackupRestoreJobExecute(r interface{}) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call { + return &SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateSharedClusterBackupRestoreJobExecute", r)} +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call) Run(run func(r admin.CreateSharedClusterBackupRestoreJobApiRequest)) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateSharedClusterBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call) Return(_a0 *admin.TenantRestore, _a1 *http.Response, _a2 error) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error)) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateSharedClusterBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierRestoreJobsApi) CreateSharedClusterBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateSharedClusterBackupRestoreJobApiParams) admin.CreateSharedClusterBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateSharedClusterBackupRestoreJobWithParams") + } + + var r0 admin.CreateSharedClusterBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateSharedClusterBackupRestoreJobApiParams) admin.CreateSharedClusterBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateSharedClusterBackupRestoreJobApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSharedClusterBackupRestoreJobWithParams' +type SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// CreateSharedClusterBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateSharedClusterBackupRestoreJobApiParams +func (_e *SharedTierRestoreJobsApi_Expecter) CreateSharedClusterBackupRestoreJobWithParams(ctx interface{}, args interface{}) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call { + return &SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateSharedClusterBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateSharedClusterBackupRestoreJobApiParams)) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateSharedClusterBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateSharedClusterBackupRestoreJobApiParams) admin.CreateSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_CreateSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackupRestoreJob provides a mock function with given fields: ctx, clusterName, groupId, restoreId +func (_m *SharedTierRestoreJobsApi) GetSharedClusterBackupRestoreJob(ctx context.Context, clusterName string, groupId string, restoreId string) admin.GetSharedClusterBackupRestoreJobApiRequest { + ret := _m.Called(ctx, clusterName, groupId, restoreId) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackupRestoreJob") + } + + var r0 admin.GetSharedClusterBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetSharedClusterBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, clusterName, groupId, restoreId) + } else { + r0 = ret.Get(0).(admin.GetSharedClusterBackupRestoreJobApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackupRestoreJob' +type SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call struct { + *mock.Call +} + +// GetSharedClusterBackupRestoreJob is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - groupId string +// - restoreId string +func (_e *SharedTierRestoreJobsApi_Expecter) GetSharedClusterBackupRestoreJob(ctx interface{}, clusterName interface{}, groupId interface{}, restoreId interface{}) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call { + return &SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call{Call: _e.mock.On("GetSharedClusterBackupRestoreJob", ctx, clusterName, groupId, restoreId)} +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call) Run(run func(ctx context.Context, clusterName string, groupId string, restoreId string)) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_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 *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call) Return(_a0 admin.GetSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJob_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackupRestoreJobExecute provides a mock function with given fields: r +func (_m *SharedTierRestoreJobsApi) GetSharedClusterBackupRestoreJobExecute(r admin.GetSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackupRestoreJobExecute") + } + + var r0 *admin.TenantRestore + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetSharedClusterBackupRestoreJobApiRequest) *admin.TenantRestore); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.TenantRestore) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetSharedClusterBackupRestoreJobApiRequest) *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.GetSharedClusterBackupRestoreJobApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackupRestoreJobExecute' +type SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call struct { + *mock.Call +} + +// GetSharedClusterBackupRestoreJobExecute is a helper method to define mock.On call +// - r admin.GetSharedClusterBackupRestoreJobApiRequest +func (_e *SharedTierRestoreJobsApi_Expecter) GetSharedClusterBackupRestoreJobExecute(r interface{}) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call { + return &SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call{Call: _e.mock.On("GetSharedClusterBackupRestoreJobExecute", r)} +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call) Run(run func(r admin.GetSharedClusterBackupRestoreJobApiRequest)) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetSharedClusterBackupRestoreJobApiRequest)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call) Return(_a0 *admin.TenantRestore, _a1 *http.Response, _a2 error) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetSharedClusterBackupRestoreJobApiRequest) (*admin.TenantRestore, *http.Response, error)) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackupRestoreJobWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierRestoreJobsApi) GetSharedClusterBackupRestoreJobWithParams(ctx context.Context, args *admin.GetSharedClusterBackupRestoreJobApiParams) admin.GetSharedClusterBackupRestoreJobApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackupRestoreJobWithParams") + } + + var r0 admin.GetSharedClusterBackupRestoreJobApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetSharedClusterBackupRestoreJobApiParams) admin.GetSharedClusterBackupRestoreJobApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetSharedClusterBackupRestoreJobApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackupRestoreJobWithParams' +type SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call struct { + *mock.Call +} + +// GetSharedClusterBackupRestoreJobWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetSharedClusterBackupRestoreJobApiParams +func (_e *SharedTierRestoreJobsApi_Expecter) GetSharedClusterBackupRestoreJobWithParams(ctx interface{}, args interface{}) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call { + return &SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetSharedClusterBackupRestoreJobWithParams", ctx, args)} +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call) Run(run func(ctx context.Context, args *admin.GetSharedClusterBackupRestoreJobApiParams)) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetSharedClusterBackupRestoreJobApiParams)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call) Return(_a0 admin.GetSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetSharedClusterBackupRestoreJobApiParams) admin.GetSharedClusterBackupRestoreJobApiRequest) *SharedTierRestoreJobsApi_GetSharedClusterBackupRestoreJobWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackupRestoreJobs provides a mock function with given fields: ctx, clusterName, groupId +func (_m *SharedTierRestoreJobsApi) ListSharedClusterBackupRestoreJobs(ctx context.Context, clusterName string, groupId string) admin.ListSharedClusterBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, clusterName, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackupRestoreJobs") + } + + var r0 admin.ListSharedClusterBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSharedClusterBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, clusterName, groupId) + } else { + r0 = ret.Get(0).(admin.ListSharedClusterBackupRestoreJobsApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackupRestoreJobs' +type SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call struct { + *mock.Call +} + +// ListSharedClusterBackupRestoreJobs is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - groupId string +func (_e *SharedTierRestoreJobsApi_Expecter) ListSharedClusterBackupRestoreJobs(ctx interface{}, clusterName interface{}, groupId interface{}) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call { + return &SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call{Call: _e.mock.On("ListSharedClusterBackupRestoreJobs", ctx, clusterName, groupId)} +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call) Run(run func(ctx context.Context, clusterName string, groupId string)) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call) Return(_a0 admin.ListSharedClusterBackupRestoreJobsApiRequest) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSharedClusterBackupRestoreJobsApiRequest) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobs_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackupRestoreJobsExecute provides a mock function with given fields: r +func (_m *SharedTierRestoreJobsApi) ListSharedClusterBackupRestoreJobsExecute(r admin.ListSharedClusterBackupRestoreJobsApiRequest) (*admin.PaginatedTenantRestore, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackupRestoreJobsExecute") + } + + var r0 *admin.PaginatedTenantRestore + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSharedClusterBackupRestoreJobsApiRequest) (*admin.PaginatedTenantRestore, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSharedClusterBackupRestoreJobsApiRequest) *admin.PaginatedTenantRestore); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedTenantRestore) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSharedClusterBackupRestoreJobsApiRequest) *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.ListSharedClusterBackupRestoreJobsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackupRestoreJobsExecute' +type SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call struct { + *mock.Call +} + +// ListSharedClusterBackupRestoreJobsExecute is a helper method to define mock.On call +// - r admin.ListSharedClusterBackupRestoreJobsApiRequest +func (_e *SharedTierRestoreJobsApi_Expecter) ListSharedClusterBackupRestoreJobsExecute(r interface{}) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call { + return &SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListSharedClusterBackupRestoreJobsExecute", r)} +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call) Run(run func(r admin.ListSharedClusterBackupRestoreJobsApiRequest)) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSharedClusterBackupRestoreJobsApiRequest)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call) Return(_a0 *admin.PaginatedTenantRestore, _a1 *http.Response, _a2 error) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListSharedClusterBackupRestoreJobsApiRequest) (*admin.PaginatedTenantRestore, *http.Response, error)) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierRestoreJobsApi) ListSharedClusterBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListSharedClusterBackupRestoreJobsApiParams) admin.ListSharedClusterBackupRestoreJobsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackupRestoreJobsWithParams") + } + + var r0 admin.ListSharedClusterBackupRestoreJobsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSharedClusterBackupRestoreJobsApiParams) admin.ListSharedClusterBackupRestoreJobsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSharedClusterBackupRestoreJobsApiRequest) + } + + return r0 +} + +// SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackupRestoreJobsWithParams' +type SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call struct { + *mock.Call +} + +// ListSharedClusterBackupRestoreJobsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSharedClusterBackupRestoreJobsApiParams +func (_e *SharedTierRestoreJobsApi_Expecter) ListSharedClusterBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call { + return &SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListSharedClusterBackupRestoreJobsWithParams", ctx, args)} +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSharedClusterBackupRestoreJobsApiParams)) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSharedClusterBackupRestoreJobsApiParams)) + }) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListSharedClusterBackupRestoreJobsApiRequest) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSharedClusterBackupRestoreJobsApiParams) admin.ListSharedClusterBackupRestoreJobsApiRequest) *SharedTierRestoreJobsApi_ListSharedClusterBackupRestoreJobsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewSharedTierRestoreJobsApi creates a new instance of SharedTierRestoreJobsApi. 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 NewSharedTierRestoreJobsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *SharedTierRestoreJobsApi { + mock := &SharedTierRestoreJobsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/shared_tier_snapshots_api.go b/mockadmin/shared_tier_snapshots_api.go new file mode 100644 index 000000000..10cf9c628 --- /dev/null +++ b/mockadmin/shared_tier_snapshots_api.go @@ -0,0 +1,528 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// SharedTierSnapshotsApi is an autogenerated mock type for the SharedTierSnapshotsApi type +type SharedTierSnapshotsApi struct { + mock.Mock +} + +type SharedTierSnapshotsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *SharedTierSnapshotsApi) EXPECT() *SharedTierSnapshotsApi_Expecter { + return &SharedTierSnapshotsApi_Expecter{mock: &_m.Mock} +} + +// DownloadSharedClusterBackup provides a mock function with given fields: ctx, clusterName, groupId, tenantRestore +func (_m *SharedTierSnapshotsApi) DownloadSharedClusterBackup(ctx context.Context, clusterName string, groupId string, tenantRestore *admin.TenantRestore) admin.DownloadSharedClusterBackupApiRequest { + ret := _m.Called(ctx, clusterName, groupId, tenantRestore) + + if len(ret) == 0 { + panic("no return value specified for DownloadSharedClusterBackup") + } + + var r0 admin.DownloadSharedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TenantRestore) admin.DownloadSharedClusterBackupApiRequest); ok { + r0 = rf(ctx, clusterName, groupId, tenantRestore) + } else { + r0 = ret.Get(0).(admin.DownloadSharedClusterBackupApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadSharedClusterBackup' +type SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call struct { + *mock.Call +} + +// DownloadSharedClusterBackup is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - groupId string +// - tenantRestore *admin.TenantRestore +func (_e *SharedTierSnapshotsApi_Expecter) DownloadSharedClusterBackup(ctx interface{}, clusterName interface{}, groupId interface{}, tenantRestore interface{}) *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call { + return &SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call{Call: _e.mock.On("DownloadSharedClusterBackup", ctx, clusterName, groupId, tenantRestore)} +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call) Run(run func(ctx context.Context, clusterName string, groupId string, tenantRestore *admin.TenantRestore)) *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TenantRestore)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call) Return(_a0 admin.DownloadSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call) RunAndReturn(run func(context.Context, string, string, *admin.TenantRestore) admin.DownloadSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_DownloadSharedClusterBackup_Call { + _c.Call.Return(run) + return _c +} + +// DownloadSharedClusterBackupExecute provides a mock function with given fields: r +func (_m *SharedTierSnapshotsApi) DownloadSharedClusterBackupExecute(r admin.DownloadSharedClusterBackupApiRequest) (*admin.TenantRestore, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DownloadSharedClusterBackupExecute") + } + + var r0 *admin.TenantRestore + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DownloadSharedClusterBackupApiRequest) (*admin.TenantRestore, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DownloadSharedClusterBackupApiRequest) *admin.TenantRestore); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.TenantRestore) + } + } + + if rf, ok := ret.Get(1).(func(admin.DownloadSharedClusterBackupApiRequest) *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.DownloadSharedClusterBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadSharedClusterBackupExecute' +type SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call struct { + *mock.Call +} + +// DownloadSharedClusterBackupExecute is a helper method to define mock.On call +// - r admin.DownloadSharedClusterBackupApiRequest +func (_e *SharedTierSnapshotsApi_Expecter) DownloadSharedClusterBackupExecute(r interface{}) *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call { + return &SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call{Call: _e.mock.On("DownloadSharedClusterBackupExecute", r)} +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call) Run(run func(r admin.DownloadSharedClusterBackupApiRequest)) *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DownloadSharedClusterBackupApiRequest)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call) Return(_a0 *admin.TenantRestore, _a1 *http.Response, _a2 error) *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call) RunAndReturn(run func(admin.DownloadSharedClusterBackupApiRequest) (*admin.TenantRestore, *http.Response, error)) *SharedTierSnapshotsApi_DownloadSharedClusterBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// DownloadSharedClusterBackupWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierSnapshotsApi) DownloadSharedClusterBackupWithParams(ctx context.Context, args *admin.DownloadSharedClusterBackupApiParams) admin.DownloadSharedClusterBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DownloadSharedClusterBackupWithParams") + } + + var r0 admin.DownloadSharedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadSharedClusterBackupApiParams) admin.DownloadSharedClusterBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DownloadSharedClusterBackupApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadSharedClusterBackupWithParams' +type SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call struct { + *mock.Call +} + +// DownloadSharedClusterBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DownloadSharedClusterBackupApiParams +func (_e *SharedTierSnapshotsApi_Expecter) DownloadSharedClusterBackupWithParams(ctx interface{}, args interface{}) *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call { + return &SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call{Call: _e.mock.On("DownloadSharedClusterBackupWithParams", ctx, args)} +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadSharedClusterBackupApiParams)) *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DownloadSharedClusterBackupApiParams)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call) Return(_a0 admin.DownloadSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadSharedClusterBackupApiParams) admin.DownloadSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_DownloadSharedClusterBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackup provides a mock function with given fields: ctx, groupId, clusterName, snapshotId +func (_m *SharedTierSnapshotsApi) GetSharedClusterBackup(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetSharedClusterBackupApiRequest { + ret := _m.Called(ctx, groupId, clusterName, snapshotId) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackup") + } + + var r0 admin.GetSharedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetSharedClusterBackupApiRequest); ok { + r0 = rf(ctx, groupId, clusterName, snapshotId) + } else { + r0 = ret.Get(0).(admin.GetSharedClusterBackupApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_GetSharedClusterBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackup' +type SharedTierSnapshotsApi_GetSharedClusterBackup_Call struct { + *mock.Call +} + +// GetSharedClusterBackup is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +// - snapshotId string +func (_e *SharedTierSnapshotsApi_Expecter) GetSharedClusterBackup(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *SharedTierSnapshotsApi_GetSharedClusterBackup_Call { + return &SharedTierSnapshotsApi_GetSharedClusterBackup_Call{Call: _e.mock.On("GetSharedClusterBackup", ctx, groupId, clusterName, snapshotId)} +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *SharedTierSnapshotsApi_GetSharedClusterBackup_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 *SharedTierSnapshotsApi_GetSharedClusterBackup_Call) Return(_a0 admin.GetSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_GetSharedClusterBackup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackup_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_GetSharedClusterBackup_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackupExecute provides a mock function with given fields: r +func (_m *SharedTierSnapshotsApi) GetSharedClusterBackupExecute(r admin.GetSharedClusterBackupApiRequest) (*admin.BackupTenantSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackupExecute") + } + + var r0 *admin.BackupTenantSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetSharedClusterBackupApiRequest) (*admin.BackupTenantSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetSharedClusterBackupApiRequest) *admin.BackupTenantSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.BackupTenantSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetSharedClusterBackupApiRequest) *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.GetSharedClusterBackupApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackupExecute' +type SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call struct { + *mock.Call +} + +// GetSharedClusterBackupExecute is a helper method to define mock.On call +// - r admin.GetSharedClusterBackupApiRequest +func (_e *SharedTierSnapshotsApi_Expecter) GetSharedClusterBackupExecute(r interface{}) *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call { + return &SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call{Call: _e.mock.On("GetSharedClusterBackupExecute", r)} +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call) Run(run func(r admin.GetSharedClusterBackupApiRequest)) *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetSharedClusterBackupApiRequest)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call) Return(_a0 *admin.BackupTenantSnapshot, _a1 *http.Response, _a2 error) *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call) RunAndReturn(run func(admin.GetSharedClusterBackupApiRequest) (*admin.BackupTenantSnapshot, *http.Response, error)) *SharedTierSnapshotsApi_GetSharedClusterBackupExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedClusterBackupWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierSnapshotsApi) GetSharedClusterBackupWithParams(ctx context.Context, args *admin.GetSharedClusterBackupApiParams) admin.GetSharedClusterBackupApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetSharedClusterBackupWithParams") + } + + var r0 admin.GetSharedClusterBackupApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetSharedClusterBackupApiParams) admin.GetSharedClusterBackupApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetSharedClusterBackupApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedClusterBackupWithParams' +type SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call struct { + *mock.Call +} + +// GetSharedClusterBackupWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetSharedClusterBackupApiParams +func (_e *SharedTierSnapshotsApi_Expecter) GetSharedClusterBackupWithParams(ctx interface{}, args interface{}) *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call { + return &SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call{Call: _e.mock.On("GetSharedClusterBackupWithParams", ctx, args)} +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call) Run(run func(ctx context.Context, args *admin.GetSharedClusterBackupApiParams)) *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetSharedClusterBackupApiParams)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call) Return(_a0 admin.GetSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetSharedClusterBackupApiParams) admin.GetSharedClusterBackupApiRequest) *SharedTierSnapshotsApi_GetSharedClusterBackupWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackups provides a mock function with given fields: ctx, groupId, clusterName +func (_m *SharedTierSnapshotsApi) ListSharedClusterBackups(ctx context.Context, groupId string, clusterName string) admin.ListSharedClusterBackupsApiRequest { + ret := _m.Called(ctx, groupId, clusterName) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackups") + } + + var r0 admin.ListSharedClusterBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListSharedClusterBackupsApiRequest); ok { + r0 = rf(ctx, groupId, clusterName) + } else { + r0 = ret.Get(0).(admin.ListSharedClusterBackupsApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_ListSharedClusterBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackups' +type SharedTierSnapshotsApi_ListSharedClusterBackups_Call struct { + *mock.Call +} + +// ListSharedClusterBackups is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - clusterName string +func (_e *SharedTierSnapshotsApi_Expecter) ListSharedClusterBackups(ctx interface{}, groupId interface{}, clusterName interface{}) *SharedTierSnapshotsApi_ListSharedClusterBackups_Call { + return &SharedTierSnapshotsApi_ListSharedClusterBackups_Call{Call: _e.mock.On("ListSharedClusterBackups", ctx, groupId, clusterName)} +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackups_Call) Run(run func(ctx context.Context, groupId string, clusterName string)) *SharedTierSnapshotsApi_ListSharedClusterBackups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackups_Call) Return(_a0 admin.ListSharedClusterBackupsApiRequest) *SharedTierSnapshotsApi_ListSharedClusterBackups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackups_Call) RunAndReturn(run func(context.Context, string, string) admin.ListSharedClusterBackupsApiRequest) *SharedTierSnapshotsApi_ListSharedClusterBackups_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackupsExecute provides a mock function with given fields: r +func (_m *SharedTierSnapshotsApi) ListSharedClusterBackupsExecute(r admin.ListSharedClusterBackupsApiRequest) (*admin.PaginatedTenantSnapshot, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackupsExecute") + } + + var r0 *admin.PaginatedTenantSnapshot + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListSharedClusterBackupsApiRequest) (*admin.PaginatedTenantSnapshot, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListSharedClusterBackupsApiRequest) *admin.PaginatedTenantSnapshot); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedTenantSnapshot) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListSharedClusterBackupsApiRequest) *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.ListSharedClusterBackupsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackupsExecute' +type SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call struct { + *mock.Call +} + +// ListSharedClusterBackupsExecute is a helper method to define mock.On call +// - r admin.ListSharedClusterBackupsApiRequest +func (_e *SharedTierSnapshotsApi_Expecter) ListSharedClusterBackupsExecute(r interface{}) *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call { + return &SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call{Call: _e.mock.On("ListSharedClusterBackupsExecute", r)} +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call) Run(run func(r admin.ListSharedClusterBackupsApiRequest)) *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListSharedClusterBackupsApiRequest)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call) Return(_a0 *admin.PaginatedTenantSnapshot, _a1 *http.Response, _a2 error) *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call) RunAndReturn(run func(admin.ListSharedClusterBackupsApiRequest) (*admin.PaginatedTenantSnapshot, *http.Response, error)) *SharedTierSnapshotsApi_ListSharedClusterBackupsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListSharedClusterBackupsWithParams provides a mock function with given fields: ctx, args +func (_m *SharedTierSnapshotsApi) ListSharedClusterBackupsWithParams(ctx context.Context, args *admin.ListSharedClusterBackupsApiParams) admin.ListSharedClusterBackupsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListSharedClusterBackupsWithParams") + } + + var r0 admin.ListSharedClusterBackupsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSharedClusterBackupsApiParams) admin.ListSharedClusterBackupsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListSharedClusterBackupsApiRequest) + } + + return r0 +} + +// SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSharedClusterBackupsWithParams' +type SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call struct { + *mock.Call +} + +// ListSharedClusterBackupsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListSharedClusterBackupsApiParams +func (_e *SharedTierSnapshotsApi_Expecter) ListSharedClusterBackupsWithParams(ctx interface{}, args interface{}) *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call { + return &SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call{Call: _e.mock.On("ListSharedClusterBackupsWithParams", ctx, args)} +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSharedClusterBackupsApiParams)) *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListSharedClusterBackupsApiParams)) + }) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call) Return(_a0 admin.ListSharedClusterBackupsApiRequest) *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSharedClusterBackupsApiParams) admin.ListSharedClusterBackupsApiRequest) *SharedTierSnapshotsApi_ListSharedClusterBackupsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewSharedTierSnapshotsApi creates a new instance of SharedTierSnapshotsApi. 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 NewSharedTierSnapshotsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *SharedTierSnapshotsApi { + mock := &SharedTierSnapshotsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/streams_api.go b/mockadmin/streams_api.go new file mode 100644 index 000000000..8c5cdf509 --- /dev/null +++ b/mockadmin/streams_api.go @@ -0,0 +1,1829 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + io "io" + + mock "github.com/stretchr/testify/mock" +) + +// StreamsApi is an autogenerated mock type for the StreamsApi type +type StreamsApi struct { + mock.Mock +} + +type StreamsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *StreamsApi) EXPECT() *StreamsApi_Expecter { + return &StreamsApi_Expecter{mock: &_m.Mock} +} + +// CreateStreamConnection provides a mock function with given fields: ctx, groupId, tenantName, streamsConnection +func (_m *StreamsApi) CreateStreamConnection(ctx context.Context, groupId string, tenantName string, streamsConnection *admin.StreamsConnection) admin.CreateStreamConnectionApiRequest { + ret := _m.Called(ctx, groupId, tenantName, streamsConnection) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamConnection") + } + + var r0 admin.CreateStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.StreamsConnection) admin.CreateStreamConnectionApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, streamsConnection) + } else { + r0 = ret.Get(0).(admin.CreateStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_CreateStreamConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamConnection' +type StreamsApi_CreateStreamConnection_Call struct { + *mock.Call +} + +// CreateStreamConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - streamsConnection *admin.StreamsConnection +func (_e *StreamsApi_Expecter) CreateStreamConnection(ctx interface{}, groupId interface{}, tenantName interface{}, streamsConnection interface{}) *StreamsApi_CreateStreamConnection_Call { + return &StreamsApi_CreateStreamConnection_Call{Call: _e.mock.On("CreateStreamConnection", ctx, groupId, tenantName, streamsConnection)} +} + +func (_c *StreamsApi_CreateStreamConnection_Call) Run(run func(ctx context.Context, groupId string, tenantName string, streamsConnection *admin.StreamsConnection)) *StreamsApi_CreateStreamConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.StreamsConnection)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamConnection_Call) Return(_a0 admin.CreateStreamConnectionApiRequest) *StreamsApi_CreateStreamConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_CreateStreamConnection_Call) RunAndReturn(run func(context.Context, string, string, *admin.StreamsConnection) admin.CreateStreamConnectionApiRequest) *StreamsApi_CreateStreamConnection_Call { + _c.Call.Return(run) + return _c +} + +// CreateStreamConnectionExecute provides a mock function with given fields: r +func (_m *StreamsApi) CreateStreamConnectionExecute(r admin.CreateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamConnectionExecute") + } + + var r0 *admin.StreamsConnection + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateStreamConnectionApiRequest) *admin.StreamsConnection); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsConnection) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateStreamConnectionApiRequest) *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.CreateStreamConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_CreateStreamConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamConnectionExecute' +type StreamsApi_CreateStreamConnectionExecute_Call struct { + *mock.Call +} + +// CreateStreamConnectionExecute is a helper method to define mock.On call +// - r admin.CreateStreamConnectionApiRequest +func (_e *StreamsApi_Expecter) CreateStreamConnectionExecute(r interface{}) *StreamsApi_CreateStreamConnectionExecute_Call { + return &StreamsApi_CreateStreamConnectionExecute_Call{Call: _e.mock.On("CreateStreamConnectionExecute", r)} +} + +func (_c *StreamsApi_CreateStreamConnectionExecute_Call) Run(run func(r admin.CreateStreamConnectionApiRequest)) *StreamsApi_CreateStreamConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateStreamConnectionApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamConnectionExecute_Call) Return(_a0 *admin.StreamsConnection, _a1 *http.Response, _a2 error) *StreamsApi_CreateStreamConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_CreateStreamConnectionExecute_Call) RunAndReturn(run func(admin.CreateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)) *StreamsApi_CreateStreamConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateStreamConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) CreateStreamConnectionWithParams(ctx context.Context, args *admin.CreateStreamConnectionApiParams) admin.CreateStreamConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamConnectionWithParams") + } + + var r0 admin.CreateStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateStreamConnectionApiParams) admin.CreateStreamConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_CreateStreamConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamConnectionWithParams' +type StreamsApi_CreateStreamConnectionWithParams_Call struct { + *mock.Call +} + +// CreateStreamConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateStreamConnectionApiParams +func (_e *StreamsApi_Expecter) CreateStreamConnectionWithParams(ctx interface{}, args interface{}) *StreamsApi_CreateStreamConnectionWithParams_Call { + return &StreamsApi_CreateStreamConnectionWithParams_Call{Call: _e.mock.On("CreateStreamConnectionWithParams", ctx, args)} +} + +func (_c *StreamsApi_CreateStreamConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateStreamConnectionApiParams)) *StreamsApi_CreateStreamConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateStreamConnectionApiParams)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamConnectionWithParams_Call) Return(_a0 admin.CreateStreamConnectionApiRequest) *StreamsApi_CreateStreamConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_CreateStreamConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateStreamConnectionApiParams) admin.CreateStreamConnectionApiRequest) *StreamsApi_CreateStreamConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// CreateStreamInstance provides a mock function with given fields: ctx, groupId, streamsTenant +func (_m *StreamsApi) CreateStreamInstance(ctx context.Context, groupId string, streamsTenant *admin.StreamsTenant) admin.CreateStreamInstanceApiRequest { + ret := _m.Called(ctx, groupId, streamsTenant) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamInstance") + } + + var r0 admin.CreateStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *admin.StreamsTenant) admin.CreateStreamInstanceApiRequest); ok { + r0 = rf(ctx, groupId, streamsTenant) + } else { + r0 = ret.Get(0).(admin.CreateStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_CreateStreamInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamInstance' +type StreamsApi_CreateStreamInstance_Call struct { + *mock.Call +} + +// CreateStreamInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - streamsTenant *admin.StreamsTenant +func (_e *StreamsApi_Expecter) CreateStreamInstance(ctx interface{}, groupId interface{}, streamsTenant interface{}) *StreamsApi_CreateStreamInstance_Call { + return &StreamsApi_CreateStreamInstance_Call{Call: _e.mock.On("CreateStreamInstance", ctx, groupId, streamsTenant)} +} + +func (_c *StreamsApi_CreateStreamInstance_Call) Run(run func(ctx context.Context, groupId string, streamsTenant *admin.StreamsTenant)) *StreamsApi_CreateStreamInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*admin.StreamsTenant)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamInstance_Call) Return(_a0 admin.CreateStreamInstanceApiRequest) *StreamsApi_CreateStreamInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_CreateStreamInstance_Call) RunAndReturn(run func(context.Context, string, *admin.StreamsTenant) admin.CreateStreamInstanceApiRequest) *StreamsApi_CreateStreamInstance_Call { + _c.Call.Return(run) + return _c +} + +// CreateStreamInstanceExecute provides a mock function with given fields: r +func (_m *StreamsApi) CreateStreamInstanceExecute(r admin.CreateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamInstanceExecute") + } + + var r0 *admin.StreamsTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateStreamInstanceApiRequest) *admin.StreamsTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateStreamInstanceApiRequest) *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.CreateStreamInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_CreateStreamInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamInstanceExecute' +type StreamsApi_CreateStreamInstanceExecute_Call struct { + *mock.Call +} + +// CreateStreamInstanceExecute is a helper method to define mock.On call +// - r admin.CreateStreamInstanceApiRequest +func (_e *StreamsApi_Expecter) CreateStreamInstanceExecute(r interface{}) *StreamsApi_CreateStreamInstanceExecute_Call { + return &StreamsApi_CreateStreamInstanceExecute_Call{Call: _e.mock.On("CreateStreamInstanceExecute", r)} +} + +func (_c *StreamsApi_CreateStreamInstanceExecute_Call) Run(run func(r admin.CreateStreamInstanceApiRequest)) *StreamsApi_CreateStreamInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateStreamInstanceApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamInstanceExecute_Call) Return(_a0 *admin.StreamsTenant, _a1 *http.Response, _a2 error) *StreamsApi_CreateStreamInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_CreateStreamInstanceExecute_Call) RunAndReturn(run func(admin.CreateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)) *StreamsApi_CreateStreamInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateStreamInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) CreateStreamInstanceWithParams(ctx context.Context, args *admin.CreateStreamInstanceApiParams) admin.CreateStreamInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateStreamInstanceWithParams") + } + + var r0 admin.CreateStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateStreamInstanceApiParams) admin.CreateStreamInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_CreateStreamInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStreamInstanceWithParams' +type StreamsApi_CreateStreamInstanceWithParams_Call struct { + *mock.Call +} + +// CreateStreamInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateStreamInstanceApiParams +func (_e *StreamsApi_Expecter) CreateStreamInstanceWithParams(ctx interface{}, args interface{}) *StreamsApi_CreateStreamInstanceWithParams_Call { + return &StreamsApi_CreateStreamInstanceWithParams_Call{Call: _e.mock.On("CreateStreamInstanceWithParams", ctx, args)} +} + +func (_c *StreamsApi_CreateStreamInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateStreamInstanceApiParams)) *StreamsApi_CreateStreamInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateStreamInstanceApiParams)) + }) + return _c +} + +func (_c *StreamsApi_CreateStreamInstanceWithParams_Call) Return(_a0 admin.CreateStreamInstanceApiRequest) *StreamsApi_CreateStreamInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_CreateStreamInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateStreamInstanceApiParams) admin.CreateStreamInstanceApiRequest) *StreamsApi_CreateStreamInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamConnection provides a mock function with given fields: ctx, groupId, tenantName, connectionName +func (_m *StreamsApi) DeleteStreamConnection(ctx context.Context, groupId string, tenantName string, connectionName string) admin.DeleteStreamConnectionApiRequest { + ret := _m.Called(ctx, groupId, tenantName, connectionName) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamConnection") + } + + var r0 admin.DeleteStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteStreamConnectionApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, connectionName) + } else { + r0 = ret.Get(0).(admin.DeleteStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_DeleteStreamConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamConnection' +type StreamsApi_DeleteStreamConnection_Call struct { + *mock.Call +} + +// DeleteStreamConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - connectionName string +func (_e *StreamsApi_Expecter) DeleteStreamConnection(ctx interface{}, groupId interface{}, tenantName interface{}, connectionName interface{}) *StreamsApi_DeleteStreamConnection_Call { + return &StreamsApi_DeleteStreamConnection_Call{Call: _e.mock.On("DeleteStreamConnection", ctx, groupId, tenantName, connectionName)} +} + +func (_c *StreamsApi_DeleteStreamConnection_Call) Run(run func(ctx context.Context, groupId string, tenantName string, connectionName string)) *StreamsApi_DeleteStreamConnection_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 *StreamsApi_DeleteStreamConnection_Call) Return(_a0 admin.DeleteStreamConnectionApiRequest) *StreamsApi_DeleteStreamConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DeleteStreamConnection_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteStreamConnectionApiRequest) *StreamsApi_DeleteStreamConnection_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamConnectionExecute provides a mock function with given fields: r +func (_m *StreamsApi) DeleteStreamConnectionExecute(r admin.DeleteStreamConnectionApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamConnectionExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteStreamConnectionApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteStreamConnectionApiRequest) 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.DeleteStreamConnectionApiRequest) *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.DeleteStreamConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_DeleteStreamConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamConnectionExecute' +type StreamsApi_DeleteStreamConnectionExecute_Call struct { + *mock.Call +} + +// DeleteStreamConnectionExecute is a helper method to define mock.On call +// - r admin.DeleteStreamConnectionApiRequest +func (_e *StreamsApi_Expecter) DeleteStreamConnectionExecute(r interface{}) *StreamsApi_DeleteStreamConnectionExecute_Call { + return &StreamsApi_DeleteStreamConnectionExecute_Call{Call: _e.mock.On("DeleteStreamConnectionExecute", r)} +} + +func (_c *StreamsApi_DeleteStreamConnectionExecute_Call) Run(run func(r admin.DeleteStreamConnectionApiRequest)) *StreamsApi_DeleteStreamConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteStreamConnectionApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_DeleteStreamConnectionExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *StreamsApi_DeleteStreamConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_DeleteStreamConnectionExecute_Call) RunAndReturn(run func(admin.DeleteStreamConnectionApiRequest) (map[string]interface{}, *http.Response, error)) *StreamsApi_DeleteStreamConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) DeleteStreamConnectionWithParams(ctx context.Context, args *admin.DeleteStreamConnectionApiParams) admin.DeleteStreamConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamConnectionWithParams") + } + + var r0 admin.DeleteStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteStreamConnectionApiParams) admin.DeleteStreamConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_DeleteStreamConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamConnectionWithParams' +type StreamsApi_DeleteStreamConnectionWithParams_Call struct { + *mock.Call +} + +// DeleteStreamConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteStreamConnectionApiParams +func (_e *StreamsApi_Expecter) DeleteStreamConnectionWithParams(ctx interface{}, args interface{}) *StreamsApi_DeleteStreamConnectionWithParams_Call { + return &StreamsApi_DeleteStreamConnectionWithParams_Call{Call: _e.mock.On("DeleteStreamConnectionWithParams", ctx, args)} +} + +func (_c *StreamsApi_DeleteStreamConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteStreamConnectionApiParams)) *StreamsApi_DeleteStreamConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteStreamConnectionApiParams)) + }) + return _c +} + +func (_c *StreamsApi_DeleteStreamConnectionWithParams_Call) Return(_a0 admin.DeleteStreamConnectionApiRequest) *StreamsApi_DeleteStreamConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DeleteStreamConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteStreamConnectionApiParams) admin.DeleteStreamConnectionApiRequest) *StreamsApi_DeleteStreamConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamInstance provides a mock function with given fields: ctx, groupId, tenantName +func (_m *StreamsApi) DeleteStreamInstance(ctx context.Context, groupId string, tenantName string) admin.DeleteStreamInstanceApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamInstance") + } + + var r0 admin.DeleteStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteStreamInstanceApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.DeleteStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_DeleteStreamInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamInstance' +type StreamsApi_DeleteStreamInstance_Call struct { + *mock.Call +} + +// DeleteStreamInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *StreamsApi_Expecter) DeleteStreamInstance(ctx interface{}, groupId interface{}, tenantName interface{}) *StreamsApi_DeleteStreamInstance_Call { + return &StreamsApi_DeleteStreamInstance_Call{Call: _e.mock.On("DeleteStreamInstance", ctx, groupId, tenantName)} +} + +func (_c *StreamsApi_DeleteStreamInstance_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *StreamsApi_DeleteStreamInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstance_Call) Return(_a0 admin.DeleteStreamInstanceApiRequest) *StreamsApi_DeleteStreamInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstance_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteStreamInstanceApiRequest) *StreamsApi_DeleteStreamInstance_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamInstanceExecute provides a mock function with given fields: r +func (_m *StreamsApi) DeleteStreamInstanceExecute(r admin.DeleteStreamInstanceApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamInstanceExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteStreamInstanceApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteStreamInstanceApiRequest) 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.DeleteStreamInstanceApiRequest) *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.DeleteStreamInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_DeleteStreamInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamInstanceExecute' +type StreamsApi_DeleteStreamInstanceExecute_Call struct { + *mock.Call +} + +// DeleteStreamInstanceExecute is a helper method to define mock.On call +// - r admin.DeleteStreamInstanceApiRequest +func (_e *StreamsApi_Expecter) DeleteStreamInstanceExecute(r interface{}) *StreamsApi_DeleteStreamInstanceExecute_Call { + return &StreamsApi_DeleteStreamInstanceExecute_Call{Call: _e.mock.On("DeleteStreamInstanceExecute", r)} +} + +func (_c *StreamsApi_DeleteStreamInstanceExecute_Call) Run(run func(r admin.DeleteStreamInstanceApiRequest)) *StreamsApi_DeleteStreamInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteStreamInstanceApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstanceExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *StreamsApi_DeleteStreamInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstanceExecute_Call) RunAndReturn(run func(admin.DeleteStreamInstanceApiRequest) (map[string]interface{}, *http.Response, error)) *StreamsApi_DeleteStreamInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStreamInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) DeleteStreamInstanceWithParams(ctx context.Context, args *admin.DeleteStreamInstanceApiParams) admin.DeleteStreamInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteStreamInstanceWithParams") + } + + var r0 admin.DeleteStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteStreamInstanceApiParams) admin.DeleteStreamInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_DeleteStreamInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStreamInstanceWithParams' +type StreamsApi_DeleteStreamInstanceWithParams_Call struct { + *mock.Call +} + +// DeleteStreamInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteStreamInstanceApiParams +func (_e *StreamsApi_Expecter) DeleteStreamInstanceWithParams(ctx interface{}, args interface{}) *StreamsApi_DeleteStreamInstanceWithParams_Call { + return &StreamsApi_DeleteStreamInstanceWithParams_Call{Call: _e.mock.On("DeleteStreamInstanceWithParams", ctx, args)} +} + +func (_c *StreamsApi_DeleteStreamInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteStreamInstanceApiParams)) *StreamsApi_DeleteStreamInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteStreamInstanceApiParams)) + }) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstanceWithParams_Call) Return(_a0 admin.DeleteStreamInstanceApiRequest) *StreamsApi_DeleteStreamInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DeleteStreamInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteStreamInstanceApiParams) admin.DeleteStreamInstanceApiRequest) *StreamsApi_DeleteStreamInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DownloadStreamTenantAuditLogs provides a mock function with given fields: ctx, groupId, tenantName +func (_m *StreamsApi) DownloadStreamTenantAuditLogs(ctx context.Context, groupId string, tenantName string) admin.DownloadStreamTenantAuditLogsApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for DownloadStreamTenantAuditLogs") + } + + var r0 admin.DownloadStreamTenantAuditLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DownloadStreamTenantAuditLogsApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.DownloadStreamTenantAuditLogsApiRequest) + } + + return r0 +} + +// StreamsApi_DownloadStreamTenantAuditLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadStreamTenantAuditLogs' +type StreamsApi_DownloadStreamTenantAuditLogs_Call struct { + *mock.Call +} + +// DownloadStreamTenantAuditLogs is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *StreamsApi_Expecter) DownloadStreamTenantAuditLogs(ctx interface{}, groupId interface{}, tenantName interface{}) *StreamsApi_DownloadStreamTenantAuditLogs_Call { + return &StreamsApi_DownloadStreamTenantAuditLogs_Call{Call: _e.mock.On("DownloadStreamTenantAuditLogs", ctx, groupId, tenantName)} +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogs_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *StreamsApi_DownloadStreamTenantAuditLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogs_Call) Return(_a0 admin.DownloadStreamTenantAuditLogsApiRequest) *StreamsApi_DownloadStreamTenantAuditLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogs_Call) RunAndReturn(run func(context.Context, string, string) admin.DownloadStreamTenantAuditLogsApiRequest) *StreamsApi_DownloadStreamTenantAuditLogs_Call { + _c.Call.Return(run) + return _c +} + +// DownloadStreamTenantAuditLogsExecute provides a mock function with given fields: r +func (_m *StreamsApi) DownloadStreamTenantAuditLogsExecute(r admin.DownloadStreamTenantAuditLogsApiRequest) (io.ReadCloser, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DownloadStreamTenantAuditLogsExecute") + } + + var r0 io.ReadCloser + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DownloadStreamTenantAuditLogsApiRequest) (io.ReadCloser, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DownloadStreamTenantAuditLogsApiRequest) io.ReadCloser); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.ReadCloser) + } + } + + if rf, ok := ret.Get(1).(func(admin.DownloadStreamTenantAuditLogsApiRequest) *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.DownloadStreamTenantAuditLogsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_DownloadStreamTenantAuditLogsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadStreamTenantAuditLogsExecute' +type StreamsApi_DownloadStreamTenantAuditLogsExecute_Call struct { + *mock.Call +} + +// DownloadStreamTenantAuditLogsExecute is a helper method to define mock.On call +// - r admin.DownloadStreamTenantAuditLogsApiRequest +func (_e *StreamsApi_Expecter) DownloadStreamTenantAuditLogsExecute(r interface{}) *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call { + return &StreamsApi_DownloadStreamTenantAuditLogsExecute_Call{Call: _e.mock.On("DownloadStreamTenantAuditLogsExecute", r)} +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call) Run(run func(r admin.DownloadStreamTenantAuditLogsApiRequest)) *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DownloadStreamTenantAuditLogsApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call) RunAndReturn(run func(admin.DownloadStreamTenantAuditLogsApiRequest) (io.ReadCloser, *http.Response, error)) *StreamsApi_DownloadStreamTenantAuditLogsExecute_Call { + _c.Call.Return(run) + return _c +} + +// DownloadStreamTenantAuditLogsWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) DownloadStreamTenantAuditLogsWithParams(ctx context.Context, args *admin.DownloadStreamTenantAuditLogsApiParams) admin.DownloadStreamTenantAuditLogsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DownloadStreamTenantAuditLogsWithParams") + } + + var r0 admin.DownloadStreamTenantAuditLogsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadStreamTenantAuditLogsApiParams) admin.DownloadStreamTenantAuditLogsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DownloadStreamTenantAuditLogsApiRequest) + } + + return r0 +} + +// StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadStreamTenantAuditLogsWithParams' +type StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call struct { + *mock.Call +} + +// DownloadStreamTenantAuditLogsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DownloadStreamTenantAuditLogsApiParams +func (_e *StreamsApi_Expecter) DownloadStreamTenantAuditLogsWithParams(ctx interface{}, args interface{}) *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call { + return &StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call{Call: _e.mock.On("DownloadStreamTenantAuditLogsWithParams", ctx, args)} +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadStreamTenantAuditLogsApiParams)) *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DownloadStreamTenantAuditLogsApiParams)) + }) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call) Return(_a0 admin.DownloadStreamTenantAuditLogsApiRequest) *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadStreamTenantAuditLogsApiParams) admin.DownloadStreamTenantAuditLogsApiRequest) *StreamsApi_DownloadStreamTenantAuditLogsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamConnection provides a mock function with given fields: ctx, groupId, tenantName, connectionName +func (_m *StreamsApi) GetStreamConnection(ctx context.Context, groupId string, tenantName string, connectionName string) admin.GetStreamConnectionApiRequest { + ret := _m.Called(ctx, groupId, tenantName, connectionName) + + if len(ret) == 0 { + panic("no return value specified for GetStreamConnection") + } + + var r0 admin.GetStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.GetStreamConnectionApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, connectionName) + } else { + r0 = ret.Get(0).(admin.GetStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_GetStreamConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamConnection' +type StreamsApi_GetStreamConnection_Call struct { + *mock.Call +} + +// GetStreamConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - connectionName string +func (_e *StreamsApi_Expecter) GetStreamConnection(ctx interface{}, groupId interface{}, tenantName interface{}, connectionName interface{}) *StreamsApi_GetStreamConnection_Call { + return &StreamsApi_GetStreamConnection_Call{Call: _e.mock.On("GetStreamConnection", ctx, groupId, tenantName, connectionName)} +} + +func (_c *StreamsApi_GetStreamConnection_Call) Run(run func(ctx context.Context, groupId string, tenantName string, connectionName string)) *StreamsApi_GetStreamConnection_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 *StreamsApi_GetStreamConnection_Call) Return(_a0 admin.GetStreamConnectionApiRequest) *StreamsApi_GetStreamConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_GetStreamConnection_Call) RunAndReturn(run func(context.Context, string, string, string) admin.GetStreamConnectionApiRequest) *StreamsApi_GetStreamConnection_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamConnectionExecute provides a mock function with given fields: r +func (_m *StreamsApi) GetStreamConnectionExecute(r admin.GetStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetStreamConnectionExecute") + } + + var r0 *admin.StreamsConnection + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetStreamConnectionApiRequest) *admin.StreamsConnection); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsConnection) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetStreamConnectionApiRequest) *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.GetStreamConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_GetStreamConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamConnectionExecute' +type StreamsApi_GetStreamConnectionExecute_Call struct { + *mock.Call +} + +// GetStreamConnectionExecute is a helper method to define mock.On call +// - r admin.GetStreamConnectionApiRequest +func (_e *StreamsApi_Expecter) GetStreamConnectionExecute(r interface{}) *StreamsApi_GetStreamConnectionExecute_Call { + return &StreamsApi_GetStreamConnectionExecute_Call{Call: _e.mock.On("GetStreamConnectionExecute", r)} +} + +func (_c *StreamsApi_GetStreamConnectionExecute_Call) Run(run func(r admin.GetStreamConnectionApiRequest)) *StreamsApi_GetStreamConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetStreamConnectionApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_GetStreamConnectionExecute_Call) Return(_a0 *admin.StreamsConnection, _a1 *http.Response, _a2 error) *StreamsApi_GetStreamConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_GetStreamConnectionExecute_Call) RunAndReturn(run func(admin.GetStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)) *StreamsApi_GetStreamConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) GetStreamConnectionWithParams(ctx context.Context, args *admin.GetStreamConnectionApiParams) admin.GetStreamConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetStreamConnectionWithParams") + } + + var r0 admin.GetStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetStreamConnectionApiParams) admin.GetStreamConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_GetStreamConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamConnectionWithParams' +type StreamsApi_GetStreamConnectionWithParams_Call struct { + *mock.Call +} + +// GetStreamConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetStreamConnectionApiParams +func (_e *StreamsApi_Expecter) GetStreamConnectionWithParams(ctx interface{}, args interface{}) *StreamsApi_GetStreamConnectionWithParams_Call { + return &StreamsApi_GetStreamConnectionWithParams_Call{Call: _e.mock.On("GetStreamConnectionWithParams", ctx, args)} +} + +func (_c *StreamsApi_GetStreamConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.GetStreamConnectionApiParams)) *StreamsApi_GetStreamConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetStreamConnectionApiParams)) + }) + return _c +} + +func (_c *StreamsApi_GetStreamConnectionWithParams_Call) Return(_a0 admin.GetStreamConnectionApiRequest) *StreamsApi_GetStreamConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_GetStreamConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetStreamConnectionApiParams) admin.GetStreamConnectionApiRequest) *StreamsApi_GetStreamConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamInstance provides a mock function with given fields: ctx, groupId, tenantName +func (_m *StreamsApi) GetStreamInstance(ctx context.Context, groupId string, tenantName string) admin.GetStreamInstanceApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for GetStreamInstance") + } + + var r0 admin.GetStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetStreamInstanceApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.GetStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_GetStreamInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamInstance' +type StreamsApi_GetStreamInstance_Call struct { + *mock.Call +} + +// GetStreamInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *StreamsApi_Expecter) GetStreamInstance(ctx interface{}, groupId interface{}, tenantName interface{}) *StreamsApi_GetStreamInstance_Call { + return &StreamsApi_GetStreamInstance_Call{Call: _e.mock.On("GetStreamInstance", ctx, groupId, tenantName)} +} + +func (_c *StreamsApi_GetStreamInstance_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *StreamsApi_GetStreamInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *StreamsApi_GetStreamInstance_Call) Return(_a0 admin.GetStreamInstanceApiRequest) *StreamsApi_GetStreamInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_GetStreamInstance_Call) RunAndReturn(run func(context.Context, string, string) admin.GetStreamInstanceApiRequest) *StreamsApi_GetStreamInstance_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamInstanceExecute provides a mock function with given fields: r +func (_m *StreamsApi) GetStreamInstanceExecute(r admin.GetStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetStreamInstanceExecute") + } + + var r0 *admin.StreamsTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetStreamInstanceApiRequest) *admin.StreamsTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetStreamInstanceApiRequest) *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.GetStreamInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_GetStreamInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamInstanceExecute' +type StreamsApi_GetStreamInstanceExecute_Call struct { + *mock.Call +} + +// GetStreamInstanceExecute is a helper method to define mock.On call +// - r admin.GetStreamInstanceApiRequest +func (_e *StreamsApi_Expecter) GetStreamInstanceExecute(r interface{}) *StreamsApi_GetStreamInstanceExecute_Call { + return &StreamsApi_GetStreamInstanceExecute_Call{Call: _e.mock.On("GetStreamInstanceExecute", r)} +} + +func (_c *StreamsApi_GetStreamInstanceExecute_Call) Run(run func(r admin.GetStreamInstanceApiRequest)) *StreamsApi_GetStreamInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetStreamInstanceApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_GetStreamInstanceExecute_Call) Return(_a0 *admin.StreamsTenant, _a1 *http.Response, _a2 error) *StreamsApi_GetStreamInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_GetStreamInstanceExecute_Call) RunAndReturn(run func(admin.GetStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)) *StreamsApi_GetStreamInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetStreamInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) GetStreamInstanceWithParams(ctx context.Context, args *admin.GetStreamInstanceApiParams) admin.GetStreamInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetStreamInstanceWithParams") + } + + var r0 admin.GetStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetStreamInstanceApiParams) admin.GetStreamInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_GetStreamInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStreamInstanceWithParams' +type StreamsApi_GetStreamInstanceWithParams_Call struct { + *mock.Call +} + +// GetStreamInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetStreamInstanceApiParams +func (_e *StreamsApi_Expecter) GetStreamInstanceWithParams(ctx interface{}, args interface{}) *StreamsApi_GetStreamInstanceWithParams_Call { + return &StreamsApi_GetStreamInstanceWithParams_Call{Call: _e.mock.On("GetStreamInstanceWithParams", ctx, args)} +} + +func (_c *StreamsApi_GetStreamInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.GetStreamInstanceApiParams)) *StreamsApi_GetStreamInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetStreamInstanceApiParams)) + }) + return _c +} + +func (_c *StreamsApi_GetStreamInstanceWithParams_Call) Return(_a0 admin.GetStreamInstanceApiRequest) *StreamsApi_GetStreamInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_GetStreamInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetStreamInstanceApiParams) admin.GetStreamInstanceApiRequest) *StreamsApi_GetStreamInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamConnections provides a mock function with given fields: ctx, groupId, tenantName +func (_m *StreamsApi) ListStreamConnections(ctx context.Context, groupId string, tenantName string) admin.ListStreamConnectionsApiRequest { + ret := _m.Called(ctx, groupId, tenantName) + + if len(ret) == 0 { + panic("no return value specified for ListStreamConnections") + } + + var r0 admin.ListStreamConnectionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListStreamConnectionsApiRequest); ok { + r0 = rf(ctx, groupId, tenantName) + } else { + r0 = ret.Get(0).(admin.ListStreamConnectionsApiRequest) + } + + return r0 +} + +// StreamsApi_ListStreamConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamConnections' +type StreamsApi_ListStreamConnections_Call struct { + *mock.Call +} + +// ListStreamConnections is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +func (_e *StreamsApi_Expecter) ListStreamConnections(ctx interface{}, groupId interface{}, tenantName interface{}) *StreamsApi_ListStreamConnections_Call { + return &StreamsApi_ListStreamConnections_Call{Call: _e.mock.On("ListStreamConnections", ctx, groupId, tenantName)} +} + +func (_c *StreamsApi_ListStreamConnections_Call) Run(run func(ctx context.Context, groupId string, tenantName string)) *StreamsApi_ListStreamConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamConnections_Call) Return(_a0 admin.ListStreamConnectionsApiRequest) *StreamsApi_ListStreamConnections_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_ListStreamConnections_Call) RunAndReturn(run func(context.Context, string, string) admin.ListStreamConnectionsApiRequest) *StreamsApi_ListStreamConnections_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamConnectionsExecute provides a mock function with given fields: r +func (_m *StreamsApi) ListStreamConnectionsExecute(r admin.ListStreamConnectionsApiRequest) (*admin.PaginatedApiStreamsConnection, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListStreamConnectionsExecute") + } + + var r0 *admin.PaginatedApiStreamsConnection + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListStreamConnectionsApiRequest) (*admin.PaginatedApiStreamsConnection, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListStreamConnectionsApiRequest) *admin.PaginatedApiStreamsConnection); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiStreamsConnection) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListStreamConnectionsApiRequest) *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.ListStreamConnectionsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_ListStreamConnectionsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamConnectionsExecute' +type StreamsApi_ListStreamConnectionsExecute_Call struct { + *mock.Call +} + +// ListStreamConnectionsExecute is a helper method to define mock.On call +// - r admin.ListStreamConnectionsApiRequest +func (_e *StreamsApi_Expecter) ListStreamConnectionsExecute(r interface{}) *StreamsApi_ListStreamConnectionsExecute_Call { + return &StreamsApi_ListStreamConnectionsExecute_Call{Call: _e.mock.On("ListStreamConnectionsExecute", r)} +} + +func (_c *StreamsApi_ListStreamConnectionsExecute_Call) Run(run func(r admin.ListStreamConnectionsApiRequest)) *StreamsApi_ListStreamConnectionsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListStreamConnectionsApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamConnectionsExecute_Call) Return(_a0 *admin.PaginatedApiStreamsConnection, _a1 *http.Response, _a2 error) *StreamsApi_ListStreamConnectionsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_ListStreamConnectionsExecute_Call) RunAndReturn(run func(admin.ListStreamConnectionsApiRequest) (*admin.PaginatedApiStreamsConnection, *http.Response, error)) *StreamsApi_ListStreamConnectionsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamConnectionsWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) ListStreamConnectionsWithParams(ctx context.Context, args *admin.ListStreamConnectionsApiParams) admin.ListStreamConnectionsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListStreamConnectionsWithParams") + } + + var r0 admin.ListStreamConnectionsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListStreamConnectionsApiParams) admin.ListStreamConnectionsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListStreamConnectionsApiRequest) + } + + return r0 +} + +// StreamsApi_ListStreamConnectionsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamConnectionsWithParams' +type StreamsApi_ListStreamConnectionsWithParams_Call struct { + *mock.Call +} + +// ListStreamConnectionsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListStreamConnectionsApiParams +func (_e *StreamsApi_Expecter) ListStreamConnectionsWithParams(ctx interface{}, args interface{}) *StreamsApi_ListStreamConnectionsWithParams_Call { + return &StreamsApi_ListStreamConnectionsWithParams_Call{Call: _e.mock.On("ListStreamConnectionsWithParams", ctx, args)} +} + +func (_c *StreamsApi_ListStreamConnectionsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListStreamConnectionsApiParams)) *StreamsApi_ListStreamConnectionsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListStreamConnectionsApiParams)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamConnectionsWithParams_Call) Return(_a0 admin.ListStreamConnectionsApiRequest) *StreamsApi_ListStreamConnectionsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_ListStreamConnectionsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListStreamConnectionsApiParams) admin.ListStreamConnectionsApiRequest) *StreamsApi_ListStreamConnectionsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamInstances provides a mock function with given fields: ctx, groupId +func (_m *StreamsApi) ListStreamInstances(ctx context.Context, groupId string) admin.ListStreamInstancesApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListStreamInstances") + } + + var r0 admin.ListStreamInstancesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListStreamInstancesApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListStreamInstancesApiRequest) + } + + return r0 +} + +// StreamsApi_ListStreamInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamInstances' +type StreamsApi_ListStreamInstances_Call struct { + *mock.Call +} + +// ListStreamInstances is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *StreamsApi_Expecter) ListStreamInstances(ctx interface{}, groupId interface{}) *StreamsApi_ListStreamInstances_Call { + return &StreamsApi_ListStreamInstances_Call{Call: _e.mock.On("ListStreamInstances", ctx, groupId)} +} + +func (_c *StreamsApi_ListStreamInstances_Call) Run(run func(ctx context.Context, groupId string)) *StreamsApi_ListStreamInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamInstances_Call) Return(_a0 admin.ListStreamInstancesApiRequest) *StreamsApi_ListStreamInstances_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_ListStreamInstances_Call) RunAndReturn(run func(context.Context, string) admin.ListStreamInstancesApiRequest) *StreamsApi_ListStreamInstances_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamInstancesExecute provides a mock function with given fields: r +func (_m *StreamsApi) ListStreamInstancesExecute(r admin.ListStreamInstancesApiRequest) (*admin.PaginatedApiStreamsTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListStreamInstancesExecute") + } + + var r0 *admin.PaginatedApiStreamsTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListStreamInstancesApiRequest) (*admin.PaginatedApiStreamsTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListStreamInstancesApiRequest) *admin.PaginatedApiStreamsTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedApiStreamsTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListStreamInstancesApiRequest) *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.ListStreamInstancesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_ListStreamInstancesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamInstancesExecute' +type StreamsApi_ListStreamInstancesExecute_Call struct { + *mock.Call +} + +// ListStreamInstancesExecute is a helper method to define mock.On call +// - r admin.ListStreamInstancesApiRequest +func (_e *StreamsApi_Expecter) ListStreamInstancesExecute(r interface{}) *StreamsApi_ListStreamInstancesExecute_Call { + return &StreamsApi_ListStreamInstancesExecute_Call{Call: _e.mock.On("ListStreamInstancesExecute", r)} +} + +func (_c *StreamsApi_ListStreamInstancesExecute_Call) Run(run func(r admin.ListStreamInstancesApiRequest)) *StreamsApi_ListStreamInstancesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListStreamInstancesApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamInstancesExecute_Call) Return(_a0 *admin.PaginatedApiStreamsTenant, _a1 *http.Response, _a2 error) *StreamsApi_ListStreamInstancesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_ListStreamInstancesExecute_Call) RunAndReturn(run func(admin.ListStreamInstancesApiRequest) (*admin.PaginatedApiStreamsTenant, *http.Response, error)) *StreamsApi_ListStreamInstancesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListStreamInstancesWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) ListStreamInstancesWithParams(ctx context.Context, args *admin.ListStreamInstancesApiParams) admin.ListStreamInstancesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListStreamInstancesWithParams") + } + + var r0 admin.ListStreamInstancesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListStreamInstancesApiParams) admin.ListStreamInstancesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListStreamInstancesApiRequest) + } + + return r0 +} + +// StreamsApi_ListStreamInstancesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStreamInstancesWithParams' +type StreamsApi_ListStreamInstancesWithParams_Call struct { + *mock.Call +} + +// ListStreamInstancesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListStreamInstancesApiParams +func (_e *StreamsApi_Expecter) ListStreamInstancesWithParams(ctx interface{}, args interface{}) *StreamsApi_ListStreamInstancesWithParams_Call { + return &StreamsApi_ListStreamInstancesWithParams_Call{Call: _e.mock.On("ListStreamInstancesWithParams", ctx, args)} +} + +func (_c *StreamsApi_ListStreamInstancesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListStreamInstancesApiParams)) *StreamsApi_ListStreamInstancesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListStreamInstancesApiParams)) + }) + return _c +} + +func (_c *StreamsApi_ListStreamInstancesWithParams_Call) Return(_a0 admin.ListStreamInstancesApiRequest) *StreamsApi_ListStreamInstancesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_ListStreamInstancesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListStreamInstancesApiParams) admin.ListStreamInstancesApiRequest) *StreamsApi_ListStreamInstancesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamConnection provides a mock function with given fields: ctx, groupId, tenantName, connectionName, streamsConnection +func (_m *StreamsApi) UpdateStreamConnection(ctx context.Context, groupId string, tenantName string, connectionName string, streamsConnection *admin.StreamsConnection) admin.UpdateStreamConnectionApiRequest { + ret := _m.Called(ctx, groupId, tenantName, connectionName, streamsConnection) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamConnection") + } + + var r0 admin.UpdateStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.StreamsConnection) admin.UpdateStreamConnectionApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, connectionName, streamsConnection) + } else { + r0 = ret.Get(0).(admin.UpdateStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_UpdateStreamConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamConnection' +type StreamsApi_UpdateStreamConnection_Call struct { + *mock.Call +} + +// UpdateStreamConnection is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - connectionName string +// - streamsConnection *admin.StreamsConnection +func (_e *StreamsApi_Expecter) UpdateStreamConnection(ctx interface{}, groupId interface{}, tenantName interface{}, connectionName interface{}, streamsConnection interface{}) *StreamsApi_UpdateStreamConnection_Call { + return &StreamsApi_UpdateStreamConnection_Call{Call: _e.mock.On("UpdateStreamConnection", ctx, groupId, tenantName, connectionName, streamsConnection)} +} + +func (_c *StreamsApi_UpdateStreamConnection_Call) Run(run func(ctx context.Context, groupId string, tenantName string, connectionName string, streamsConnection *admin.StreamsConnection)) *StreamsApi_UpdateStreamConnection_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.StreamsConnection)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnection_Call) Return(_a0 admin.UpdateStreamConnectionApiRequest) *StreamsApi_UpdateStreamConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnection_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.StreamsConnection) admin.UpdateStreamConnectionApiRequest) *StreamsApi_UpdateStreamConnection_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamConnectionExecute provides a mock function with given fields: r +func (_m *StreamsApi) UpdateStreamConnectionExecute(r admin.UpdateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamConnectionExecute") + } + + var r0 *admin.StreamsConnection + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateStreamConnectionApiRequest) *admin.StreamsConnection); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsConnection) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateStreamConnectionApiRequest) *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.UpdateStreamConnectionApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_UpdateStreamConnectionExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamConnectionExecute' +type StreamsApi_UpdateStreamConnectionExecute_Call struct { + *mock.Call +} + +// UpdateStreamConnectionExecute is a helper method to define mock.On call +// - r admin.UpdateStreamConnectionApiRequest +func (_e *StreamsApi_Expecter) UpdateStreamConnectionExecute(r interface{}) *StreamsApi_UpdateStreamConnectionExecute_Call { + return &StreamsApi_UpdateStreamConnectionExecute_Call{Call: _e.mock.On("UpdateStreamConnectionExecute", r)} +} + +func (_c *StreamsApi_UpdateStreamConnectionExecute_Call) Run(run func(r admin.UpdateStreamConnectionApiRequest)) *StreamsApi_UpdateStreamConnectionExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateStreamConnectionApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnectionExecute_Call) Return(_a0 *admin.StreamsConnection, _a1 *http.Response, _a2 error) *StreamsApi_UpdateStreamConnectionExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnectionExecute_Call) RunAndReturn(run func(admin.UpdateStreamConnectionApiRequest) (*admin.StreamsConnection, *http.Response, error)) *StreamsApi_UpdateStreamConnectionExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamConnectionWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) UpdateStreamConnectionWithParams(ctx context.Context, args *admin.UpdateStreamConnectionApiParams) admin.UpdateStreamConnectionApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamConnectionWithParams") + } + + var r0 admin.UpdateStreamConnectionApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateStreamConnectionApiParams) admin.UpdateStreamConnectionApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateStreamConnectionApiRequest) + } + + return r0 +} + +// StreamsApi_UpdateStreamConnectionWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamConnectionWithParams' +type StreamsApi_UpdateStreamConnectionWithParams_Call struct { + *mock.Call +} + +// UpdateStreamConnectionWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateStreamConnectionApiParams +func (_e *StreamsApi_Expecter) UpdateStreamConnectionWithParams(ctx interface{}, args interface{}) *StreamsApi_UpdateStreamConnectionWithParams_Call { + return &StreamsApi_UpdateStreamConnectionWithParams_Call{Call: _e.mock.On("UpdateStreamConnectionWithParams", ctx, args)} +} + +func (_c *StreamsApi_UpdateStreamConnectionWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateStreamConnectionApiParams)) *StreamsApi_UpdateStreamConnectionWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateStreamConnectionApiParams)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnectionWithParams_Call) Return(_a0 admin.UpdateStreamConnectionApiRequest) *StreamsApi_UpdateStreamConnectionWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_UpdateStreamConnectionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateStreamConnectionApiParams) admin.UpdateStreamConnectionApiRequest) *StreamsApi_UpdateStreamConnectionWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamInstance provides a mock function with given fields: ctx, groupId, tenantName, streamsDataProcessRegion +func (_m *StreamsApi) UpdateStreamInstance(ctx context.Context, groupId string, tenantName string, streamsDataProcessRegion *admin.StreamsDataProcessRegion) admin.UpdateStreamInstanceApiRequest { + ret := _m.Called(ctx, groupId, tenantName, streamsDataProcessRegion) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamInstance") + } + + var r0 admin.UpdateStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.StreamsDataProcessRegion) admin.UpdateStreamInstanceApiRequest); ok { + r0 = rf(ctx, groupId, tenantName, streamsDataProcessRegion) + } else { + r0 = ret.Get(0).(admin.UpdateStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_UpdateStreamInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamInstance' +type StreamsApi_UpdateStreamInstance_Call struct { + *mock.Call +} + +// UpdateStreamInstance is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - tenantName string +// - streamsDataProcessRegion *admin.StreamsDataProcessRegion +func (_e *StreamsApi_Expecter) UpdateStreamInstance(ctx interface{}, groupId interface{}, tenantName interface{}, streamsDataProcessRegion interface{}) *StreamsApi_UpdateStreamInstance_Call { + return &StreamsApi_UpdateStreamInstance_Call{Call: _e.mock.On("UpdateStreamInstance", ctx, groupId, tenantName, streamsDataProcessRegion)} +} + +func (_c *StreamsApi_UpdateStreamInstance_Call) Run(run func(ctx context.Context, groupId string, tenantName string, streamsDataProcessRegion *admin.StreamsDataProcessRegion)) *StreamsApi_UpdateStreamInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.StreamsDataProcessRegion)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstance_Call) Return(_a0 admin.UpdateStreamInstanceApiRequest) *StreamsApi_UpdateStreamInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstance_Call) RunAndReturn(run func(context.Context, string, string, *admin.StreamsDataProcessRegion) admin.UpdateStreamInstanceApiRequest) *StreamsApi_UpdateStreamInstance_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamInstanceExecute provides a mock function with given fields: r +func (_m *StreamsApi) UpdateStreamInstanceExecute(r admin.UpdateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamInstanceExecute") + } + + var r0 *admin.StreamsTenant + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateStreamInstanceApiRequest) *admin.StreamsTenant); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.StreamsTenant) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateStreamInstanceApiRequest) *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.UpdateStreamInstanceApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// StreamsApi_UpdateStreamInstanceExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamInstanceExecute' +type StreamsApi_UpdateStreamInstanceExecute_Call struct { + *mock.Call +} + +// UpdateStreamInstanceExecute is a helper method to define mock.On call +// - r admin.UpdateStreamInstanceApiRequest +func (_e *StreamsApi_Expecter) UpdateStreamInstanceExecute(r interface{}) *StreamsApi_UpdateStreamInstanceExecute_Call { + return &StreamsApi_UpdateStreamInstanceExecute_Call{Call: _e.mock.On("UpdateStreamInstanceExecute", r)} +} + +func (_c *StreamsApi_UpdateStreamInstanceExecute_Call) Run(run func(r admin.UpdateStreamInstanceApiRequest)) *StreamsApi_UpdateStreamInstanceExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateStreamInstanceApiRequest)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstanceExecute_Call) Return(_a0 *admin.StreamsTenant, _a1 *http.Response, _a2 error) *StreamsApi_UpdateStreamInstanceExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstanceExecute_Call) RunAndReturn(run func(admin.UpdateStreamInstanceApiRequest) (*admin.StreamsTenant, *http.Response, error)) *StreamsApi_UpdateStreamInstanceExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStreamInstanceWithParams provides a mock function with given fields: ctx, args +func (_m *StreamsApi) UpdateStreamInstanceWithParams(ctx context.Context, args *admin.UpdateStreamInstanceApiParams) admin.UpdateStreamInstanceApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateStreamInstanceWithParams") + } + + var r0 admin.UpdateStreamInstanceApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateStreamInstanceApiParams) admin.UpdateStreamInstanceApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateStreamInstanceApiRequest) + } + + return r0 +} + +// StreamsApi_UpdateStreamInstanceWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStreamInstanceWithParams' +type StreamsApi_UpdateStreamInstanceWithParams_Call struct { + *mock.Call +} + +// UpdateStreamInstanceWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateStreamInstanceApiParams +func (_e *StreamsApi_Expecter) UpdateStreamInstanceWithParams(ctx interface{}, args interface{}) *StreamsApi_UpdateStreamInstanceWithParams_Call { + return &StreamsApi_UpdateStreamInstanceWithParams_Call{Call: _e.mock.On("UpdateStreamInstanceWithParams", ctx, args)} +} + +func (_c *StreamsApi_UpdateStreamInstanceWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateStreamInstanceApiParams)) *StreamsApi_UpdateStreamInstanceWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateStreamInstanceApiParams)) + }) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstanceWithParams_Call) Return(_a0 admin.UpdateStreamInstanceApiRequest) *StreamsApi_UpdateStreamInstanceWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StreamsApi_UpdateStreamInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateStreamInstanceApiParams) admin.UpdateStreamInstanceApiRequest) *StreamsApi_UpdateStreamInstanceWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewStreamsApi creates a new instance of StreamsApi. 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 NewStreamsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *StreamsApi { + mock := &StreamsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/teams_api.go b/mockadmin/teams_api.go new file mode 100644 index 000000000..ecad99804 --- /dev/null +++ b/mockadmin/teams_api.go @@ -0,0 +1,2130 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +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/mockadmin/third_party_integrations_api.go b/mockadmin/third_party_integrations_api.go new file mode 100644 index 000000000..6eb468aed --- /dev/null +++ b/mockadmin/third_party_integrations_api.go @@ -0,0 +1,851 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// ThirdPartyIntegrationsApi is an autogenerated mock type for the ThirdPartyIntegrationsApi type +type ThirdPartyIntegrationsApi struct { + mock.Mock +} + +type ThirdPartyIntegrationsApi_Expecter struct { + mock *mock.Mock +} + +func (_m *ThirdPartyIntegrationsApi) EXPECT() *ThirdPartyIntegrationsApi_Expecter { + return &ThirdPartyIntegrationsApi_Expecter{mock: &_m.Mock} +} + +// CreateThirdPartyIntegration provides a mock function with given fields: ctx, integrationType, groupId, thirdPartyIntegration +func (_m *ThirdPartyIntegrationsApi) CreateThirdPartyIntegration(ctx context.Context, integrationType string, groupId string, thirdPartyIntegration *admin.ThirdPartyIntegration) admin.CreateThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, integrationType, groupId, thirdPartyIntegration) + + if len(ret) == 0 { + panic("no return value specified for CreateThirdPartyIntegration") + } + + var r0 admin.CreateThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ThirdPartyIntegration) admin.CreateThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, integrationType, groupId, thirdPartyIntegration) + } else { + r0 = ret.Get(0).(admin.CreateThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateThirdPartyIntegration' +type ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call struct { + *mock.Call +} + +// CreateThirdPartyIntegration is a helper method to define mock.On call +// - ctx context.Context +// - integrationType string +// - groupId string +// - thirdPartyIntegration *admin.ThirdPartyIntegration +func (_e *ThirdPartyIntegrationsApi_Expecter) CreateThirdPartyIntegration(ctx interface{}, integrationType interface{}, groupId interface{}, thirdPartyIntegration interface{}) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call { + return &ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call{Call: _e.mock.On("CreateThirdPartyIntegration", ctx, integrationType, groupId, thirdPartyIntegration)} +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call) Run(run func(ctx context.Context, integrationType string, groupId string, thirdPartyIntegration *admin.ThirdPartyIntegration)) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ThirdPartyIntegration)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call) Return(_a0 admin.CreateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call) RunAndReturn(run func(context.Context, string, string, *admin.ThirdPartyIntegration) admin.CreateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegration_Call { + _c.Call.Return(run) + return _c +} + +// CreateThirdPartyIntegrationExecute provides a mock function with given fields: r +func (_m *ThirdPartyIntegrationsApi) CreateThirdPartyIntegrationExecute(r admin.CreateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateThirdPartyIntegrationExecute") + } + + var r0 *admin.PaginatedIntegration + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateThirdPartyIntegrationApiRequest) *admin.PaginatedIntegration); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedIntegration) + } + } + + if rf, ok := ret.Get(1).(func(admin.CreateThirdPartyIntegrationApiRequest) *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.CreateThirdPartyIntegrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateThirdPartyIntegrationExecute' +type ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call struct { + *mock.Call +} + +// CreateThirdPartyIntegrationExecute is a helper method to define mock.On call +// - r admin.CreateThirdPartyIntegrationApiRequest +func (_e *ThirdPartyIntegrationsApi_Expecter) CreateThirdPartyIntegrationExecute(r interface{}) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call { + return &ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call{Call: _e.mock.On("CreateThirdPartyIntegrationExecute", r)} +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call) Run(run func(r admin.CreateThirdPartyIntegrationApiRequest)) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateThirdPartyIntegrationApiRequest)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call) Return(_a0 *admin.PaginatedIntegration, _a1 *http.Response, _a2 error) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call) RunAndReturn(run func(admin.CreateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error)) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateThirdPartyIntegrationWithParams provides a mock function with given fields: ctx, args +func (_m *ThirdPartyIntegrationsApi) CreateThirdPartyIntegrationWithParams(ctx context.Context, args *admin.CreateThirdPartyIntegrationApiParams) admin.CreateThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateThirdPartyIntegrationWithParams") + } + + var r0 admin.CreateThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateThirdPartyIntegrationApiParams) admin.CreateThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateThirdPartyIntegrationWithParams' +type ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call struct { + *mock.Call +} + +// CreateThirdPartyIntegrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateThirdPartyIntegrationApiParams +func (_e *ThirdPartyIntegrationsApi_Expecter) CreateThirdPartyIntegrationWithParams(ctx interface{}, args interface{}) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call { + return &ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call{Call: _e.mock.On("CreateThirdPartyIntegrationWithParams", ctx, args)} +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateThirdPartyIntegrationApiParams)) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateThirdPartyIntegrationApiParams)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call) Return(_a0 admin.CreateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateThirdPartyIntegrationApiParams) admin.CreateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_CreateThirdPartyIntegrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DeleteThirdPartyIntegration provides a mock function with given fields: ctx, integrationType, groupId +func (_m *ThirdPartyIntegrationsApi) DeleteThirdPartyIntegration(ctx context.Context, integrationType string, groupId string) admin.DeleteThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, integrationType, groupId) + + if len(ret) == 0 { + panic("no return value specified for DeleteThirdPartyIntegration") + } + + var r0 admin.DeleteThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, integrationType, groupId) + } else { + r0 = ret.Get(0).(admin.DeleteThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteThirdPartyIntegration' +type ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call struct { + *mock.Call +} + +// DeleteThirdPartyIntegration is a helper method to define mock.On call +// - ctx context.Context +// - integrationType string +// - groupId string +func (_e *ThirdPartyIntegrationsApi_Expecter) DeleteThirdPartyIntegration(ctx interface{}, integrationType interface{}, groupId interface{}) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call { + return &ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call{Call: _e.mock.On("DeleteThirdPartyIntegration", ctx, integrationType, groupId)} +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call) Run(run func(ctx context.Context, integrationType string, groupId string)) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call) Return(_a0 admin.DeleteThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteThirdPartyIntegrationExecute provides a mock function with given fields: r +func (_m *ThirdPartyIntegrationsApi) DeleteThirdPartyIntegrationExecute(r admin.DeleteThirdPartyIntegrationApiRequest) (map[string]interface{}, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DeleteThirdPartyIntegrationExecute") + } + + var r0 map[string]interface{} + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DeleteThirdPartyIntegrationApiRequest) (map[string]interface{}, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DeleteThirdPartyIntegrationApiRequest) 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.DeleteThirdPartyIntegrationApiRequest) *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.DeleteThirdPartyIntegrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteThirdPartyIntegrationExecute' +type ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call struct { + *mock.Call +} + +// DeleteThirdPartyIntegrationExecute is a helper method to define mock.On call +// - r admin.DeleteThirdPartyIntegrationApiRequest +func (_e *ThirdPartyIntegrationsApi_Expecter) DeleteThirdPartyIntegrationExecute(r interface{}) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call { + return &ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call{Call: _e.mock.On("DeleteThirdPartyIntegrationExecute", r)} +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call) Run(run func(r admin.DeleteThirdPartyIntegrationApiRequest)) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DeleteThirdPartyIntegrationApiRequest)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call) RunAndReturn(run func(admin.DeleteThirdPartyIntegrationApiRequest) (map[string]interface{}, *http.Response, error)) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// DeleteThirdPartyIntegrationWithParams provides a mock function with given fields: ctx, args +func (_m *ThirdPartyIntegrationsApi) DeleteThirdPartyIntegrationWithParams(ctx context.Context, args *admin.DeleteThirdPartyIntegrationApiParams) admin.DeleteThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DeleteThirdPartyIntegrationWithParams") + } + + var r0 admin.DeleteThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteThirdPartyIntegrationApiParams) admin.DeleteThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DeleteThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteThirdPartyIntegrationWithParams' +type ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call struct { + *mock.Call +} + +// DeleteThirdPartyIntegrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DeleteThirdPartyIntegrationApiParams +func (_e *ThirdPartyIntegrationsApi_Expecter) DeleteThirdPartyIntegrationWithParams(ctx interface{}, args interface{}) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call { + return &ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call{Call: _e.mock.On("DeleteThirdPartyIntegrationWithParams", ctx, args)} +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteThirdPartyIntegrationApiParams)) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DeleteThirdPartyIntegrationApiParams)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call) Return(_a0 admin.DeleteThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteThirdPartyIntegrationApiParams) admin.DeleteThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_DeleteThirdPartyIntegrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// GetThirdPartyIntegration provides a mock function with given fields: ctx, groupId, integrationType +func (_m *ThirdPartyIntegrationsApi) GetThirdPartyIntegration(ctx context.Context, groupId string, integrationType string) admin.GetThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, groupId, integrationType) + + if len(ret) == 0 { + panic("no return value specified for GetThirdPartyIntegration") + } + + var r0 admin.GetThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, groupId, integrationType) + } else { + r0 = ret.Get(0).(admin.GetThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetThirdPartyIntegration' +type ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call struct { + *mock.Call +} + +// GetThirdPartyIntegration is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - integrationType string +func (_e *ThirdPartyIntegrationsApi_Expecter) GetThirdPartyIntegration(ctx interface{}, groupId interface{}, integrationType interface{}) *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call { + return &ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call{Call: _e.mock.On("GetThirdPartyIntegration", ctx, groupId, integrationType)} +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call) Run(run func(ctx context.Context, groupId string, integrationType string)) *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call) Return(_a0 admin.GetThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call) RunAndReturn(run func(context.Context, string, string) admin.GetThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_GetThirdPartyIntegration_Call { + _c.Call.Return(run) + return _c +} + +// GetThirdPartyIntegrationExecute provides a mock function with given fields: r +func (_m *ThirdPartyIntegrationsApi) GetThirdPartyIntegrationExecute(r admin.GetThirdPartyIntegrationApiRequest) (*admin.ThirdPartyIntegration, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for GetThirdPartyIntegrationExecute") + } + + var r0 *admin.ThirdPartyIntegration + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.GetThirdPartyIntegrationApiRequest) (*admin.ThirdPartyIntegration, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.GetThirdPartyIntegrationApiRequest) *admin.ThirdPartyIntegration); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.ThirdPartyIntegration) + } + } + + if rf, ok := ret.Get(1).(func(admin.GetThirdPartyIntegrationApiRequest) *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.GetThirdPartyIntegrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetThirdPartyIntegrationExecute' +type ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call struct { + *mock.Call +} + +// GetThirdPartyIntegrationExecute is a helper method to define mock.On call +// - r admin.GetThirdPartyIntegrationApiRequest +func (_e *ThirdPartyIntegrationsApi_Expecter) GetThirdPartyIntegrationExecute(r interface{}) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call { + return &ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call{Call: _e.mock.On("GetThirdPartyIntegrationExecute", r)} +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call) Run(run func(r admin.GetThirdPartyIntegrationApiRequest)) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.GetThirdPartyIntegrationApiRequest)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call) Return(_a0 *admin.ThirdPartyIntegration, _a1 *http.Response, _a2 error) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call) RunAndReturn(run func(admin.GetThirdPartyIntegrationApiRequest) (*admin.ThirdPartyIntegration, *http.Response, error)) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// GetThirdPartyIntegrationWithParams provides a mock function with given fields: ctx, args +func (_m *ThirdPartyIntegrationsApi) GetThirdPartyIntegrationWithParams(ctx context.Context, args *admin.GetThirdPartyIntegrationApiParams) admin.GetThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for GetThirdPartyIntegrationWithParams") + } + + var r0 admin.GetThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.GetThirdPartyIntegrationApiParams) admin.GetThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.GetThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetThirdPartyIntegrationWithParams' +type ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call struct { + *mock.Call +} + +// GetThirdPartyIntegrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.GetThirdPartyIntegrationApiParams +func (_e *ThirdPartyIntegrationsApi_Expecter) GetThirdPartyIntegrationWithParams(ctx interface{}, args interface{}) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call { + return &ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call{Call: _e.mock.On("GetThirdPartyIntegrationWithParams", ctx, args)} +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetThirdPartyIntegrationApiParams)) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.GetThirdPartyIntegrationApiParams)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call) Return(_a0 admin.GetThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetThirdPartyIntegrationApiParams) admin.GetThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_GetThirdPartyIntegrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListThirdPartyIntegrations provides a mock function with given fields: ctx, groupId +func (_m *ThirdPartyIntegrationsApi) ListThirdPartyIntegrations(ctx context.Context, groupId string) admin.ListThirdPartyIntegrationsApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for ListThirdPartyIntegrations") + } + + var r0 admin.ListThirdPartyIntegrationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListThirdPartyIntegrationsApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.ListThirdPartyIntegrationsApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListThirdPartyIntegrations' +type ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call struct { + *mock.Call +} + +// ListThirdPartyIntegrations is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *ThirdPartyIntegrationsApi_Expecter) ListThirdPartyIntegrations(ctx interface{}, groupId interface{}) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call { + return &ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call{Call: _e.mock.On("ListThirdPartyIntegrations", ctx, groupId)} +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call) Run(run func(ctx context.Context, groupId string)) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call) Return(_a0 admin.ListThirdPartyIntegrationsApiRequest) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call) RunAndReturn(run func(context.Context, string) admin.ListThirdPartyIntegrationsApiRequest) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrations_Call { + _c.Call.Return(run) + return _c +} + +// ListThirdPartyIntegrationsExecute provides a mock function with given fields: r +func (_m *ThirdPartyIntegrationsApi) ListThirdPartyIntegrationsExecute(r admin.ListThirdPartyIntegrationsApiRequest) (*admin.PaginatedIntegration, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListThirdPartyIntegrationsExecute") + } + + var r0 *admin.PaginatedIntegration + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListThirdPartyIntegrationsApiRequest) (*admin.PaginatedIntegration, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListThirdPartyIntegrationsApiRequest) *admin.PaginatedIntegration); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedIntegration) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListThirdPartyIntegrationsApiRequest) *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.ListThirdPartyIntegrationsApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListThirdPartyIntegrationsExecute' +type ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call struct { + *mock.Call +} + +// ListThirdPartyIntegrationsExecute is a helper method to define mock.On call +// - r admin.ListThirdPartyIntegrationsApiRequest +func (_e *ThirdPartyIntegrationsApi_Expecter) ListThirdPartyIntegrationsExecute(r interface{}) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call { + return &ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call{Call: _e.mock.On("ListThirdPartyIntegrationsExecute", r)} +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call) Run(run func(r admin.ListThirdPartyIntegrationsApiRequest)) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListThirdPartyIntegrationsApiRequest)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call) Return(_a0 *admin.PaginatedIntegration, _a1 *http.Response, _a2 error) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call) RunAndReturn(run func(admin.ListThirdPartyIntegrationsApiRequest) (*admin.PaginatedIntegration, *http.Response, error)) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListThirdPartyIntegrationsWithParams provides a mock function with given fields: ctx, args +func (_m *ThirdPartyIntegrationsApi) ListThirdPartyIntegrationsWithParams(ctx context.Context, args *admin.ListThirdPartyIntegrationsApiParams) admin.ListThirdPartyIntegrationsApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListThirdPartyIntegrationsWithParams") + } + + var r0 admin.ListThirdPartyIntegrationsApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListThirdPartyIntegrationsApiParams) admin.ListThirdPartyIntegrationsApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListThirdPartyIntegrationsApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListThirdPartyIntegrationsWithParams' +type ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call struct { + *mock.Call +} + +// ListThirdPartyIntegrationsWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListThirdPartyIntegrationsApiParams +func (_e *ThirdPartyIntegrationsApi_Expecter) ListThirdPartyIntegrationsWithParams(ctx interface{}, args interface{}) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call { + return &ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call{Call: _e.mock.On("ListThirdPartyIntegrationsWithParams", ctx, args)} +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListThirdPartyIntegrationsApiParams)) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListThirdPartyIntegrationsApiParams)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call) Return(_a0 admin.ListThirdPartyIntegrationsApiRequest) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListThirdPartyIntegrationsApiParams) admin.ListThirdPartyIntegrationsApiRequest) *ThirdPartyIntegrationsApi_ListThirdPartyIntegrationsWithParams_Call { + _c.Call.Return(run) + return _c +} + +// UpdateThirdPartyIntegration provides a mock function with given fields: ctx, integrationType, groupId, thirdPartyIntegration +func (_m *ThirdPartyIntegrationsApi) UpdateThirdPartyIntegration(ctx context.Context, integrationType string, groupId string, thirdPartyIntegration *admin.ThirdPartyIntegration) admin.UpdateThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, integrationType, groupId, thirdPartyIntegration) + + if len(ret) == 0 { + panic("no return value specified for UpdateThirdPartyIntegration") + } + + var r0 admin.UpdateThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ThirdPartyIntegration) admin.UpdateThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, integrationType, groupId, thirdPartyIntegration) + } else { + r0 = ret.Get(0).(admin.UpdateThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateThirdPartyIntegration' +type ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call struct { + *mock.Call +} + +// UpdateThirdPartyIntegration is a helper method to define mock.On call +// - ctx context.Context +// - integrationType string +// - groupId string +// - thirdPartyIntegration *admin.ThirdPartyIntegration +func (_e *ThirdPartyIntegrationsApi_Expecter) UpdateThirdPartyIntegration(ctx interface{}, integrationType interface{}, groupId interface{}, thirdPartyIntegration interface{}) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call { + return &ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call{Call: _e.mock.On("UpdateThirdPartyIntegration", ctx, integrationType, groupId, thirdPartyIntegration)} +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call) Run(run func(ctx context.Context, integrationType string, groupId string, thirdPartyIntegration *admin.ThirdPartyIntegration)) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ThirdPartyIntegration)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call) Return(_a0 admin.UpdateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call) RunAndReturn(run func(context.Context, string, string, *admin.ThirdPartyIntegration) admin.UpdateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegration_Call { + _c.Call.Return(run) + return _c +} + +// UpdateThirdPartyIntegrationExecute provides a mock function with given fields: r +func (_m *ThirdPartyIntegrationsApi) UpdateThirdPartyIntegrationExecute(r admin.UpdateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for UpdateThirdPartyIntegrationExecute") + } + + var r0 *admin.PaginatedIntegration + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.UpdateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.UpdateThirdPartyIntegrationApiRequest) *admin.PaginatedIntegration); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedIntegration) + } + } + + if rf, ok := ret.Get(1).(func(admin.UpdateThirdPartyIntegrationApiRequest) *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.UpdateThirdPartyIntegrationApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateThirdPartyIntegrationExecute' +type ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call struct { + *mock.Call +} + +// UpdateThirdPartyIntegrationExecute is a helper method to define mock.On call +// - r admin.UpdateThirdPartyIntegrationApiRequest +func (_e *ThirdPartyIntegrationsApi_Expecter) UpdateThirdPartyIntegrationExecute(r interface{}) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call { + return &ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call{Call: _e.mock.On("UpdateThirdPartyIntegrationExecute", r)} +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call) Run(run func(r admin.UpdateThirdPartyIntegrationApiRequest)) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.UpdateThirdPartyIntegrationApiRequest)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call) Return(_a0 *admin.PaginatedIntegration, _a1 *http.Response, _a2 error) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call) RunAndReturn(run func(admin.UpdateThirdPartyIntegrationApiRequest) (*admin.PaginatedIntegration, *http.Response, error)) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationExecute_Call { + _c.Call.Return(run) + return _c +} + +// UpdateThirdPartyIntegrationWithParams provides a mock function with given fields: ctx, args +func (_m *ThirdPartyIntegrationsApi) UpdateThirdPartyIntegrationWithParams(ctx context.Context, args *admin.UpdateThirdPartyIntegrationApiParams) admin.UpdateThirdPartyIntegrationApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for UpdateThirdPartyIntegrationWithParams") + } + + var r0 admin.UpdateThirdPartyIntegrationApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateThirdPartyIntegrationApiParams) admin.UpdateThirdPartyIntegrationApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.UpdateThirdPartyIntegrationApiRequest) + } + + return r0 +} + +// ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateThirdPartyIntegrationWithParams' +type ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call struct { + *mock.Call +} + +// UpdateThirdPartyIntegrationWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.UpdateThirdPartyIntegrationApiParams +func (_e *ThirdPartyIntegrationsApi_Expecter) UpdateThirdPartyIntegrationWithParams(ctx interface{}, args interface{}) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call { + return &ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call{Call: _e.mock.On("UpdateThirdPartyIntegrationWithParams", ctx, args)} +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateThirdPartyIntegrationApiParams)) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.UpdateThirdPartyIntegrationApiParams)) + }) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call) Return(_a0 admin.UpdateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateThirdPartyIntegrationApiParams) admin.UpdateThirdPartyIntegrationApiRequest) *ThirdPartyIntegrationsApi_UpdateThirdPartyIntegrationWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewThirdPartyIntegrationsApi creates a new instance of ThirdPartyIntegrationsApi. 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 NewThirdPartyIntegrationsApi(t interface { + mock.TestingT + Cleanup(func()) +}) *ThirdPartyIntegrationsApi { + mock := &ThirdPartyIntegrationsApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mockadmin/x509_authentication_api.go b/mockadmin/x509_authentication_api.go new file mode 100644 index 000000000..6e6f290a4 --- /dev/null +++ b/mockadmin/x509_authentication_api.go @@ -0,0 +1,524 @@ +// Code generated by mockery. DO NOT EDIT. + +package mockadmin + +import ( + context "context" + + admin "go.mongodb.org/atlas-sdk/v20231115008/admin" + + http "net/http" + + mock "github.com/stretchr/testify/mock" +) + +// X509AuthenticationApi is an autogenerated mock type for the X509AuthenticationApi type +type X509AuthenticationApi struct { + mock.Mock +} + +type X509AuthenticationApi_Expecter struct { + mock *mock.Mock +} + +func (_m *X509AuthenticationApi) EXPECT() *X509AuthenticationApi_Expecter { + return &X509AuthenticationApi_Expecter{mock: &_m.Mock} +} + +// CreateDatabaseUserCertificate provides a mock function with given fields: ctx, groupId, username, userCert +func (_m *X509AuthenticationApi) CreateDatabaseUserCertificate(ctx context.Context, groupId string, username string, userCert *admin.UserCert) admin.CreateDatabaseUserCertificateApiRequest { + ret := _m.Called(ctx, groupId, username, userCert) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUserCertificate") + } + + var r0 admin.CreateDatabaseUserCertificateApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.UserCert) admin.CreateDatabaseUserCertificateApiRequest); ok { + r0 = rf(ctx, groupId, username, userCert) + } else { + r0 = ret.Get(0).(admin.CreateDatabaseUserCertificateApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_CreateDatabaseUserCertificate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUserCertificate' +type X509AuthenticationApi_CreateDatabaseUserCertificate_Call struct { + *mock.Call +} + +// CreateDatabaseUserCertificate is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - username string +// - userCert *admin.UserCert +func (_e *X509AuthenticationApi_Expecter) CreateDatabaseUserCertificate(ctx interface{}, groupId interface{}, username interface{}, userCert interface{}) *X509AuthenticationApi_CreateDatabaseUserCertificate_Call { + return &X509AuthenticationApi_CreateDatabaseUserCertificate_Call{Call: _e.mock.On("CreateDatabaseUserCertificate", ctx, groupId, username, userCert)} +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificate_Call) Run(run func(ctx context.Context, groupId string, username string, userCert *admin.UserCert)) *X509AuthenticationApi_CreateDatabaseUserCertificate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UserCert)) + }) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificate_Call) Return(_a0 admin.CreateDatabaseUserCertificateApiRequest) *X509AuthenticationApi_CreateDatabaseUserCertificate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificate_Call) RunAndReturn(run func(context.Context, string, string, *admin.UserCert) admin.CreateDatabaseUserCertificateApiRequest) *X509AuthenticationApi_CreateDatabaseUserCertificate_Call { + _c.Call.Return(run) + return _c +} + +// CreateDatabaseUserCertificateExecute provides a mock function with given fields: r +func (_m *X509AuthenticationApi) CreateDatabaseUserCertificateExecute(r admin.CreateDatabaseUserCertificateApiRequest) (string, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUserCertificateExecute") + } + + var r0 string + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.CreateDatabaseUserCertificateApiRequest) (string, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.CreateDatabaseUserCertificateApiRequest) string); ok { + r0 = rf(r) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(admin.CreateDatabaseUserCertificateApiRequest) *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.CreateDatabaseUserCertificateApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUserCertificateExecute' +type X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call struct { + *mock.Call +} + +// CreateDatabaseUserCertificateExecute is a helper method to define mock.On call +// - r admin.CreateDatabaseUserCertificateApiRequest +func (_e *X509AuthenticationApi_Expecter) CreateDatabaseUserCertificateExecute(r interface{}) *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call { + return &X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call{Call: _e.mock.On("CreateDatabaseUserCertificateExecute", r)} +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call) Run(run func(r admin.CreateDatabaseUserCertificateApiRequest)) *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.CreateDatabaseUserCertificateApiRequest)) + }) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call) RunAndReturn(run func(admin.CreateDatabaseUserCertificateApiRequest) (string, *http.Response, error)) *X509AuthenticationApi_CreateDatabaseUserCertificateExecute_Call { + _c.Call.Return(run) + return _c +} + +// CreateDatabaseUserCertificateWithParams provides a mock function with given fields: ctx, args +func (_m *X509AuthenticationApi) CreateDatabaseUserCertificateWithParams(ctx context.Context, args *admin.CreateDatabaseUserCertificateApiParams) admin.CreateDatabaseUserCertificateApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for CreateDatabaseUserCertificateWithParams") + } + + var r0 admin.CreateDatabaseUserCertificateApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateDatabaseUserCertificateApiParams) admin.CreateDatabaseUserCertificateApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.CreateDatabaseUserCertificateApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDatabaseUserCertificateWithParams' +type X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call struct { + *mock.Call +} + +// CreateDatabaseUserCertificateWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.CreateDatabaseUserCertificateApiParams +func (_e *X509AuthenticationApi_Expecter) CreateDatabaseUserCertificateWithParams(ctx interface{}, args interface{}) *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call { + return &X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call{Call: _e.mock.On("CreateDatabaseUserCertificateWithParams", ctx, args)} +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateDatabaseUserCertificateApiParams)) *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.CreateDatabaseUserCertificateApiParams)) + }) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call) Return(_a0 admin.CreateDatabaseUserCertificateApiRequest) *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateDatabaseUserCertificateApiParams) admin.CreateDatabaseUserCertificateApiRequest) *X509AuthenticationApi_CreateDatabaseUserCertificateWithParams_Call { + _c.Call.Return(run) + return _c +} + +// DisableCustomerManagedX509 provides a mock function with given fields: ctx, groupId +func (_m *X509AuthenticationApi) DisableCustomerManagedX509(ctx context.Context, groupId string) admin.DisableCustomerManagedX509ApiRequest { + ret := _m.Called(ctx, groupId) + + if len(ret) == 0 { + panic("no return value specified for DisableCustomerManagedX509") + } + + var r0 admin.DisableCustomerManagedX509ApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string) admin.DisableCustomerManagedX509ApiRequest); ok { + r0 = rf(ctx, groupId) + } else { + r0 = ret.Get(0).(admin.DisableCustomerManagedX509ApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_DisableCustomerManagedX509_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableCustomerManagedX509' +type X509AuthenticationApi_DisableCustomerManagedX509_Call struct { + *mock.Call +} + +// DisableCustomerManagedX509 is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +func (_e *X509AuthenticationApi_Expecter) DisableCustomerManagedX509(ctx interface{}, groupId interface{}) *X509AuthenticationApi_DisableCustomerManagedX509_Call { + return &X509AuthenticationApi_DisableCustomerManagedX509_Call{Call: _e.mock.On("DisableCustomerManagedX509", ctx, groupId)} +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509_Call) Run(run func(ctx context.Context, groupId string)) *X509AuthenticationApi_DisableCustomerManagedX509_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509_Call) Return(_a0 admin.DisableCustomerManagedX509ApiRequest) *X509AuthenticationApi_DisableCustomerManagedX509_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509_Call) RunAndReturn(run func(context.Context, string) admin.DisableCustomerManagedX509ApiRequest) *X509AuthenticationApi_DisableCustomerManagedX509_Call { + _c.Call.Return(run) + return _c +} + +// DisableCustomerManagedX509Execute provides a mock function with given fields: r +func (_m *X509AuthenticationApi) DisableCustomerManagedX509Execute(r admin.DisableCustomerManagedX509ApiRequest) (*admin.UserSecurity, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for DisableCustomerManagedX509Execute") + } + + var r0 *admin.UserSecurity + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.DisableCustomerManagedX509ApiRequest) (*admin.UserSecurity, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.DisableCustomerManagedX509ApiRequest) *admin.UserSecurity); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.UserSecurity) + } + } + + if rf, ok := ret.Get(1).(func(admin.DisableCustomerManagedX509ApiRequest) *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.DisableCustomerManagedX509ApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// X509AuthenticationApi_DisableCustomerManagedX509Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableCustomerManagedX509Execute' +type X509AuthenticationApi_DisableCustomerManagedX509Execute_Call struct { + *mock.Call +} + +// DisableCustomerManagedX509Execute is a helper method to define mock.On call +// - r admin.DisableCustomerManagedX509ApiRequest +func (_e *X509AuthenticationApi_Expecter) DisableCustomerManagedX509Execute(r interface{}) *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call { + return &X509AuthenticationApi_DisableCustomerManagedX509Execute_Call{Call: _e.mock.On("DisableCustomerManagedX509Execute", r)} +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call) Run(run func(r admin.DisableCustomerManagedX509ApiRequest)) *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.DisableCustomerManagedX509ApiRequest)) + }) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call) Return(_a0 *admin.UserSecurity, _a1 *http.Response, _a2 error) *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call) RunAndReturn(run func(admin.DisableCustomerManagedX509ApiRequest) (*admin.UserSecurity, *http.Response, error)) *X509AuthenticationApi_DisableCustomerManagedX509Execute_Call { + _c.Call.Return(run) + return _c +} + +// DisableCustomerManagedX509WithParams provides a mock function with given fields: ctx, args +func (_m *X509AuthenticationApi) DisableCustomerManagedX509WithParams(ctx context.Context, args *admin.DisableCustomerManagedX509ApiParams) admin.DisableCustomerManagedX509ApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for DisableCustomerManagedX509WithParams") + } + + var r0 admin.DisableCustomerManagedX509ApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.DisableCustomerManagedX509ApiParams) admin.DisableCustomerManagedX509ApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.DisableCustomerManagedX509ApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableCustomerManagedX509WithParams' +type X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call struct { + *mock.Call +} + +// DisableCustomerManagedX509WithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.DisableCustomerManagedX509ApiParams +func (_e *X509AuthenticationApi_Expecter) DisableCustomerManagedX509WithParams(ctx interface{}, args interface{}) *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call { + return &X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call{Call: _e.mock.On("DisableCustomerManagedX509WithParams", ctx, args)} +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call) Run(run func(ctx context.Context, args *admin.DisableCustomerManagedX509ApiParams)) *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.DisableCustomerManagedX509ApiParams)) + }) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call) Return(_a0 admin.DisableCustomerManagedX509ApiRequest) *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call) RunAndReturn(run func(context.Context, *admin.DisableCustomerManagedX509ApiParams) admin.DisableCustomerManagedX509ApiRequest) *X509AuthenticationApi_DisableCustomerManagedX509WithParams_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUserCertificates provides a mock function with given fields: ctx, groupId, username +func (_m *X509AuthenticationApi) ListDatabaseUserCertificates(ctx context.Context, groupId string, username string) admin.ListDatabaseUserCertificatesApiRequest { + ret := _m.Called(ctx, groupId, username) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUserCertificates") + } + + var r0 admin.ListDatabaseUserCertificatesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListDatabaseUserCertificatesApiRequest); ok { + r0 = rf(ctx, groupId, username) + } else { + r0 = ret.Get(0).(admin.ListDatabaseUserCertificatesApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_ListDatabaseUserCertificates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUserCertificates' +type X509AuthenticationApi_ListDatabaseUserCertificates_Call struct { + *mock.Call +} + +// ListDatabaseUserCertificates is a helper method to define mock.On call +// - ctx context.Context +// - groupId string +// - username string +func (_e *X509AuthenticationApi_Expecter) ListDatabaseUserCertificates(ctx interface{}, groupId interface{}, username interface{}) *X509AuthenticationApi_ListDatabaseUserCertificates_Call { + return &X509AuthenticationApi_ListDatabaseUserCertificates_Call{Call: _e.mock.On("ListDatabaseUserCertificates", ctx, groupId, username)} +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificates_Call) Run(run func(ctx context.Context, groupId string, username string)) *X509AuthenticationApi_ListDatabaseUserCertificates_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificates_Call) Return(_a0 admin.ListDatabaseUserCertificatesApiRequest) *X509AuthenticationApi_ListDatabaseUserCertificates_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificates_Call) RunAndReturn(run func(context.Context, string, string) admin.ListDatabaseUserCertificatesApiRequest) *X509AuthenticationApi_ListDatabaseUserCertificates_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUserCertificatesExecute provides a mock function with given fields: r +func (_m *X509AuthenticationApi) ListDatabaseUserCertificatesExecute(r admin.ListDatabaseUserCertificatesApiRequest) (*admin.PaginatedUserCert, *http.Response, error) { + ret := _m.Called(r) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUserCertificatesExecute") + } + + var r0 *admin.PaginatedUserCert + var r1 *http.Response + var r2 error + if rf, ok := ret.Get(0).(func(admin.ListDatabaseUserCertificatesApiRequest) (*admin.PaginatedUserCert, *http.Response, error)); ok { + return rf(r) + } + if rf, ok := ret.Get(0).(func(admin.ListDatabaseUserCertificatesApiRequest) *admin.PaginatedUserCert); ok { + r0 = rf(r) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admin.PaginatedUserCert) + } + } + + if rf, ok := ret.Get(1).(func(admin.ListDatabaseUserCertificatesApiRequest) *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.ListDatabaseUserCertificatesApiRequest) error); ok { + r2 = rf(r) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUserCertificatesExecute' +type X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call struct { + *mock.Call +} + +// ListDatabaseUserCertificatesExecute is a helper method to define mock.On call +// - r admin.ListDatabaseUserCertificatesApiRequest +func (_e *X509AuthenticationApi_Expecter) ListDatabaseUserCertificatesExecute(r interface{}) *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call { + return &X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call{Call: _e.mock.On("ListDatabaseUserCertificatesExecute", r)} +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call) Run(run func(r admin.ListDatabaseUserCertificatesApiRequest)) *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(admin.ListDatabaseUserCertificatesApiRequest)) + }) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call) Return(_a0 *admin.PaginatedUserCert, _a1 *http.Response, _a2 error) *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call) RunAndReturn(run func(admin.ListDatabaseUserCertificatesApiRequest) (*admin.PaginatedUserCert, *http.Response, error)) *X509AuthenticationApi_ListDatabaseUserCertificatesExecute_Call { + _c.Call.Return(run) + return _c +} + +// ListDatabaseUserCertificatesWithParams provides a mock function with given fields: ctx, args +func (_m *X509AuthenticationApi) ListDatabaseUserCertificatesWithParams(ctx context.Context, args *admin.ListDatabaseUserCertificatesApiParams) admin.ListDatabaseUserCertificatesApiRequest { + ret := _m.Called(ctx, args) + + if len(ret) == 0 { + panic("no return value specified for ListDatabaseUserCertificatesWithParams") + } + + var r0 admin.ListDatabaseUserCertificatesApiRequest + if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDatabaseUserCertificatesApiParams) admin.ListDatabaseUserCertificatesApiRequest); ok { + r0 = rf(ctx, args) + } else { + r0 = ret.Get(0).(admin.ListDatabaseUserCertificatesApiRequest) + } + + return r0 +} + +// X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDatabaseUserCertificatesWithParams' +type X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call struct { + *mock.Call +} + +// ListDatabaseUserCertificatesWithParams is a helper method to define mock.On call +// - ctx context.Context +// - args *admin.ListDatabaseUserCertificatesApiParams +func (_e *X509AuthenticationApi_Expecter) ListDatabaseUserCertificatesWithParams(ctx interface{}, args interface{}) *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call { + return &X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call{Call: _e.mock.On("ListDatabaseUserCertificatesWithParams", ctx, args)} +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDatabaseUserCertificatesApiParams)) *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*admin.ListDatabaseUserCertificatesApiParams)) + }) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call) Return(_a0 admin.ListDatabaseUserCertificatesApiRequest) *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDatabaseUserCertificatesApiParams) admin.ListDatabaseUserCertificatesApiRequest) *X509AuthenticationApi_ListDatabaseUserCertificatesWithParams_Call { + _c.Call.Return(run) + return _c +} + +// NewX509AuthenticationApi creates a new instance of X509AuthenticationApi. 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 NewX509AuthenticationApi(t interface { + mock.TestingT + Cleanup(func()) +}) *X509AuthenticationApi { + mock := &X509AuthenticationApi{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} From ca702fa60e320a1747e82f8ddd365898e6d017ac Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Sat, 23 Mar 2024 19:09:04 +0100 Subject: [PATCH 4/9] update Mockery version --- tools/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/Makefile b/tools/Makefile index 3d12b11bb..fc4fafdbc 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -44,5 +44,5 @@ update-version: .PHONY: generate_mocks generate_mocks: - go install github.com/vektra/mockery/v2@v2.42.0 && mockery + go install github.com/vektra/mockery/v2@v2.42.1 && mockery From 03eb5aa166bce92fc4c3786f1ce0281dd63c89a3 Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Mon, 25 Mar 2024 08:42:58 +0100 Subject: [PATCH 5/9] clean mocks before generating --- tools/Makefile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/Makefile b/tools/Makefile index fc4fafdbc..ad82db15c 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -44,5 +44,6 @@ update-version: .PHONY: generate_mocks generate_mocks: - go install github.com/vektra/mockery/v2@v2.42.1 && mockery - + go install github.com/vektra/mockery/v2@v2.42.1 + rm -Rf ../mockadmin + mockery From 0084a3b176712b156d494bb17b77031bba3f51be Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Mon, 25 Mar 2024 09:14:14 +0100 Subject: [PATCH 6/9] doc --- README.md | 6 ++++++ examples/README.md | 6 ++++++ examples/mock/cluster_test.go | 40 +++++++++++++++++++++++++++++++++++ 3 files changed, 52 insertions(+) create mode 100644 examples/mock/cluster_test.go diff --git a/README.md b/README.md index 7373d6894..7adfe4901 100644 --- a/README.md +++ b/README.md @@ -55,6 +55,12 @@ Please refer to the [docs](./docs) See [examples](./examples) +## Test Support + +[Testify Mock](https://pkg.go.dev/github.com/stretchr/testify/mock) files are generated using [Mockery](https://github.com/vektra/mockery) to help to unit test clients using Atlas Go SDK. + +See [test example with mocks](./examples/mock/cluster_test.go) + ## Contributing See our [CONTRIBUTING.md](CONTRIBUTING.md) Guide. diff --git a/examples/README.md b/examples/README.md index 0ae30e987..ce906c03f 100644 --- a/examples/README.md +++ b/examples/README.md @@ -10,3 +10,9 @@ export MONGODB_ATLAS_PUBLIC_KEY=somekey export MONGODB_ATLAS_PRIVATE_KEY=some-secret-key-for-gosdkapi go run ./aws_cluster/aws.go ``` + +Running the test example with mocks: + +```bash +go test ./mock/cluster_test.go +``` diff --git a/examples/mock/cluster_test.go b/examples/mock/cluster_test.go new file mode 100644 index 000000000..80effbaa4 --- /dev/null +++ b/examples/mock/cluster_test.go @@ -0,0 +1,40 @@ +package test + +import ( + "context" + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "go.mongodb.org/atlas-sdk/v20231115008/admin" + "go.mongodb.org/atlas-sdk/v20231115008/mockadmin" +) + +func TestListClusters(t *testing.T) { + // Create mock API. + clusterAPI := mockadmin.NewClustersApi(t) + + // Program expectations. + list := &admin.PaginatedAdvancedClusterDescription{ + TotalCount: admin.PtrInt(2), + Results: &[]admin.AdvancedClusterDescription{ + {StateName: admin.PtrString("IDLE")}, + {StateName: admin.PtrString("DELETING")}, + }, + } + clusterAPI.EXPECT().ListClusters(mock.Anything, mock.Anything).Return(admin.ListClustersApiRequest{ApiService: clusterAPI}) + clusterAPI.EXPECT().ListClustersExecute(mock.Anything).Return(list, &http.Response{StatusCode: 200}, nil) + + // Call functions using the API, they won't make real calls to Atlas API. + clusterCount, err := MyFunctionCallingListClusters(clusterAPI) + + // Assert expectations. + assert.Nil(t, err) + assert.Equal(t, 2, clusterCount) +} + +func MyFunctionCallingListClusters(clusterAPI admin.ClustersApi) (int, error) { + clusters, _, err := clusterAPI.ListClusters(context.Background(), "my_group_id").Execute() + return clusters.GetTotalCount(), err +} From 40d2202d7842df2b721459c93ba3115faa270dff Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Mon, 25 Mar 2024 12:45:15 +0100 Subject: [PATCH 7/9] Update examples/README.md Co-authored-by: Wojciech Trocki --- examples/README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/examples/README.md b/examples/README.md index ce906c03f..8326987fb 100644 --- a/examples/README.md +++ b/examples/README.md @@ -11,7 +11,11 @@ export MONGODB_ATLAS_PRIVATE_KEY=some-secret-key-for-gosdkapi go run ./aws_cluster/aws.go ``` -Running the test example with mocks: + +## Running Examples with Mocked Backend + +SDK provides mocks using mockery. +One of the SDK examples cover usage of the mockery within tests ```bash go test ./mock/cluster_test.go From 9e6865291137430dc9a46e967a63e148ac574f07 Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Mon, 25 Mar 2024 12:55:03 +0100 Subject: [PATCH 8/9] adjust doc --- examples/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/README.md b/examples/README.md index 8326987fb..995ee2b3e 100644 --- a/examples/README.md +++ b/examples/README.md @@ -14,8 +14,8 @@ go run ./aws_cluster/aws.go ## Running Examples with Mocked Backend -SDK provides mocks using mockery. -One of the SDK examples cover usage of the mockery within tests +SDK provides mocks using Testify and Mockery. +One of the SDK examples covers usage of the mockery within tests. ```bash go test ./mock/cluster_test.go From e0c37ab2bc468cfbac3985f541d5bc7b878d45d2 Mon Sep 17 00:00:00 2001 From: Leo Antoli <430982+lantoli@users.noreply.github.com> Date: Mon, 25 Mar 2024 12:56:27 +0100 Subject: [PATCH 9/9] fix VERSION_UPDATE_PATHS --- tools/releaser/scripts/version-paths.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/releaser/scripts/version-paths.sh b/tools/releaser/scripts/version-paths.sh index 4771defd4..a45c8b224 100644 --- a/tools/releaser/scripts/version-paths.sh +++ b/tools/releaser/scripts/version-paths.sh @@ -1,3 +1,3 @@ #!/bin/bash -export VERSION_UPDATE_PATHS="../**/*.go,../**/*.md,../tools/**/*.mustache,../go.mod,../.mockery.yaml" +export VERSION_UPDATE_PATHS="../**/*.go,../**/*.md,../tools/**/*.mustache,../go.mod,../.github/workflows/autoupdate-preview.yaml,../.mockery.yaml"