diff --git a/config.yaml b/config.yaml new file mode 100644 index 00000000..b62398c2 --- /dev/null +++ b/config.yaml @@ -0,0 +1,6 @@ +version: "2024-06-24" +type: "mongodb" +name: "climongo" +details: + private_key: "{mongodb_private_key}" + public_key: "{mongodb_public_key}" \ No newline at end of file diff --git a/go.mod b/go.mod index df606abd..e096305a 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( github.com/hashicorp/go-multierror v1.1.1 github.com/hashicorp/go-version v1.6.0 github.com/hashicorp/hcl/v2 v2.19.1 - github.com/hashicorp/hcp-sdk-go v0.96.0 + github.com/hashicorp/hcp-sdk-go v0.99.0 github.com/lithammer/dedent v1.1.0 github.com/manifoldco/promptui v0.9.0 github.com/mitchellh/cli v1.1.5 diff --git a/go.sum b/go.sum index cce8abe0..44a525a8 100644 --- a/go.sum +++ b/go.sum @@ -97,6 +97,8 @@ github.com/hashicorp/hcl/v2 v2.19.1 h1://i05Jqznmb2EXqa39Nsvyan2o5XyMowW5fnCKW5R github.com/hashicorp/hcl/v2 v2.19.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE= github.com/hashicorp/hcp-sdk-go v0.96.0 h1:7oI993ZN7HG7TiFg00r2Po1N5mZZryOtSX0Ec/8cCQ4= github.com/hashicorp/hcp-sdk-go v0.96.0/go.mod h1:vQ4fzdL1AmhIAbCw+4zmFe5Hbpajj3NvRWkJoVuxmAk= +github.com/hashicorp/hcp-sdk-go v0.99.0 h1:qW915thxFMIyHFLFyHuTqN1AJqZYsu+YL+IVRrpP2Ck= +github.com/hashicorp/hcp-sdk-go v0.99.0/go.mod h1:vQ4fzdL1AmhIAbCw+4zmFe5Hbpajj3NvRWkJoVuxmAk= github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= github.com/huandu/xstrings v1.3.3/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= diff --git a/internal/commands/projects/create.go b/internal/commands/projects/create.go index e98c16a6..3abb0377 100644 --- a/internal/commands/projects/create.go +++ b/internal/commands/projects/create.go @@ -156,12 +156,10 @@ func addToBillingAccount(opts *CreateOpts, projectID string) error { updateReq := billing_account_service.NewBillingAccountServiceUpdateParams() updateReq.OrganizationID = ba.OrganizationID updateReq.ID = ba.ID - updateReq.Body = &billingModels.Billing20201105UpdateBillingAccountRequest{ - OrganizationID: opts.Profile.OrganizationID, - ID: ba.ID, - ProjectIds: ba.ProjectIds, - Name: ba.Name, - Country: ba.Country, + updateReq.Body = &billingModels.BillingAccountServiceUpdateBody{ + ProjectIds: ba.ProjectIds, + Name: ba.Name, + Country: ba.Country, } updateReq.Body.ProjectIds = append(updateReq.Body.ProjectIds, projectID) diff --git a/internal/commands/vaultsecrets/integrations/create.go b/internal/commands/vaultsecrets/integrations/create.go new file mode 100644 index 00000000..3a103013 --- /dev/null +++ b/internal/commands/vaultsecrets/integrations/create.go @@ -0,0 +1,119 @@ +package integrations + +import ( + "context" + "fmt" + "os" + + preview_secret_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service" + "github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/stable/2023-06-13/client/secret_service" + "github.com/hashicorp/hcp/internal/pkg/cmd" + "github.com/hashicorp/hcp/internal/pkg/flagvalue" + "github.com/hashicorp/hcp/internal/pkg/format" + "github.com/hashicorp/hcp/internal/pkg/heredoc" + "github.com/hashicorp/hcp/internal/pkg/iostreams" + "github.com/hashicorp/hcp/internal/pkg/profile" + "github.com/posener/complete" + "gopkg.in/yaml.v3" +) + +type CreateOpts struct { + Ctx context.Context + Profile *profile.Profile + Output *format.Outputter + IO iostreams.IOStreams + + ConfigFilePath string + Client secret_service.ClientService + PreviewClient preview_secret_service.ClientService +} + +func NewCmdCreate(ctx *cmd.Context, runF func(*CreateOpts) error) *cmd.Command { + opts := &CreateOpts{ + Ctx: ctx.ShutdownCtx, + Profile: ctx.Profile, + Output: ctx.Output, + IO: ctx.IO, + Client: secret_service.New(ctx.HCP, nil), + PreviewClient: preview_secret_service.New(ctx.HCP, nil), + } + + cmd := &cmd.Command{ + Name: "create", + ShortHelp: "help", + LongHelp: heredoc.New(ctx.IO).Must(`help`), + Flags: cmd.Flags{ + Local: []*cmd.Flag{ + { + Name: "config-file", + DisplayValue: "PATH", + Description: "The path to a file containing an integration config.", + Value: flagvalue.Simple("", &opts.ConfigFilePath), + Required: true, + Autocomplete: complete.PredictFiles("*.json"), + }, + }, + }, + RunF: func(c *cmd.Command, args []string) error { + + if runF != nil { + return runF(opts) + } + + return createIntegration(opts) + }, + PersistentPreRun: func(c *cmd.Command, args []string) error { + return cmd.RequireOrgAndProject(ctx) + }, + } + + return cmd +} + +type IntegrationConfig struct { + Version string + Type string + Name string + Details map[string]interface{} +} + +func createIntegration(opts *CreateOpts) error { + // Open the file + f, err := os.ReadFile(opts.ConfigFilePath) + if err != nil { + return fmt.Errorf("failed to open config file: %w", err) + } + + var i IntegrationConfig + err = yaml.Unmarshal(f, &i) + if err != nil { + return fmt.Errorf("failed to unmarshal policy file: %w", err) + } + + if i.Type == "mongodb" { + privkey := i.Details["private_key"].(string) + pubKey := i.Details["public_key"].(string) + body := preview_secret_service.CreateMongoDBAtlasIntegrationBody{ + IntegrationName: i.Name, + MongodbAPIPrivateKey: privkey, + MongodbAPIPublicKey: pubKey, + } + resp, err := opts.PreviewClient.CreateMongoDBAtlasIntegration(&preview_secret_service.CreateMongoDBAtlasIntegrationParams{ + Context: opts.Ctx, + ProjectID: opts.Profile.ProjectID, + OrganizationID: opts.Profile.OrganizationID, + Body: body, + }, nil) + + if err != nil { + return fmt.Errorf("failed to create integration: %w", err) + } + + fmt.Fprintln(opts.IO.Err()) + fmt.Fprintf(opts.IO.Err(), "%s Successfully created integration with name %q\n", opts.IO.ColorScheme().SuccessIcon(), resp.Payload.Integration.IntegrationName) + } else { + fmt.Errorf("invalid type given") + } + + return nil +} diff --git a/internal/commands/vaultsecrets/integrations/integrations.go b/internal/commands/vaultsecrets/integrations/integrations.go new file mode 100644 index 00000000..99480666 --- /dev/null +++ b/internal/commands/vaultsecrets/integrations/integrations.go @@ -0,0 +1,26 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package integrations + +import ( + "github.com/hashicorp/hcp/internal/pkg/cmd" + "github.com/hashicorp/hcp/internal/pkg/heredoc" +) + +func NewCmdIntegrations(ctx *cmd.Context) *cmd.Command { + cmd := &cmd.Command{ + Name: "integrations", + ShortHelp: "Manage Vault Secrets integrations.", + LongHelp: heredoc.New(ctx.IO).Must(` + The {{ template "mdCodeOrBold" "hcp vault-secrets integrations" }} command group lets you + manage Vault Secrets integrations. + `), + PersistentPreRun: func(c *cmd.Command, args []string) error { + return cmd.RequireOrgAndProject(ctx) + }, + } + + cmd.AddChild(NewCmdCreate(ctx, nil)) + return cmd +} diff --git a/internal/commands/vaultsecrets/secrets/create-rotating.go b/internal/commands/vaultsecrets/secrets/create-rotating.go new file mode 100644 index 00000000..091a0450 --- /dev/null +++ b/internal/commands/vaultsecrets/secrets/create-rotating.go @@ -0,0 +1,146 @@ +package secrets + +import ( + "context" + "fmt" + "os" + + preview_secret_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service" + "github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/models" + "github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/stable/2023-06-13/client/secret_service" + "github.com/hashicorp/hcp/internal/commands/vaultsecrets/secrets/appname" + "github.com/hashicorp/hcp/internal/pkg/cmd" + "github.com/hashicorp/hcp/internal/pkg/flagvalue" + "github.com/hashicorp/hcp/internal/pkg/format" + "github.com/hashicorp/hcp/internal/pkg/heredoc" + "github.com/hashicorp/hcp/internal/pkg/iostreams" + "github.com/hashicorp/hcp/internal/pkg/profile" + "github.com/mitchellh/mapstructure" + "github.com/posener/complete" + "gopkg.in/yaml.v3" +) + +func NewCmdCreateRotating(ctx *cmd.Context, runF func(*CreateRotatingOpts) error) *cmd.Command { + opts := &CreateRotatingOpts{ + Ctx: ctx.ShutdownCtx, + Profile: ctx.Profile, + IO: ctx.IO, + Output: ctx.Output, + PreviewClient: preview_secret_service.New(ctx.HCP, nil), + Client: secret_service.New(ctx.HCP, nil), + } + + cmd := &cmd.Command{ + Name: "create-rotating", + ShortHelp: "Create a new rotating secret.", + LongHelp: heredoc.New(ctx.IO).Must(` + The {{ template "mdCodeOrBold" "hcp vault-secrets secrets create-rotating" }} command creates a new rotating secret under a Vault Secrets application. + `), + Flags: cmd.Flags{ + Local: []*cmd.Flag{ + { + Name: "config-file", + DisplayValue: "CONFIG_FILE_PATH", + Description: "File path to a secret config", + Value: flagvalue.Simple("", &opts.SecretConfigFile), + Autocomplete: complete.PredictOr( + complete.PredictFiles("*"), + complete.PredictSet("-"), + ), + }, + }, + }, + RunF: func(c *cmd.Command, args []string) error { + opts.AppName = appname.Get() + + if runF != nil { + return runF(opts) + } + return createRotatingRun(opts) + }, + } + + return cmd +} + +type CreateRotatingOpts struct { + Ctx context.Context + Profile *profile.Profile + IO iostreams.IOStreams + Output *format.Outputter + + AppName string + SecretConfigFile string + PreviewClient preview_secret_service.ClientService + Client secret_service.ClientService +} + +type RotatingSecretConfig struct { + Version string + SecretName string `yaml:"secret_name"` + RotationIntegrationType string `yaml:"rotation_integration_type"` + RotationIntegrationName string `yaml:"rotation_integration_name"` + RotationPolicyName string `yaml:"rotation_policy_name"` + Details map[string]interface{} +} + +type MongoDBRole struct { + RoleName string `mapstructure:"role_name"` + DatabaseName string `mapstructure:"database_name"` + CollectionName string `mapstructure:"collection_name"` +} + +func createRotatingRun(opts *CreateRotatingOpts) error { + fmt.Fprintf(opts.IO.Err(), "starting") + f, err := os.ReadFile(opts.SecretConfigFile) + if err != nil { + return fmt.Errorf("failed to open config file: %w", err) + } + + var rsc RotatingSecretConfig + err = yaml.Unmarshal(f, &rsc) + if err != nil { + return fmt.Errorf("failed to unmarshal policy file: %w", err) + } + fmt.Fprintf(opts.IO.Err(), "read config %+v\n", rsc) + if rsc.RotationIntegrationType == "mongodb" { + roles := rsc.Details["roles"].([]interface{}) + req := preview_secret_service.NewCreateMongoDBAtlasRotatingSecretParamsWithContext(opts.Ctx) + req.OrganizationID = opts.Profile.OrganizationID + req.ProjectID = opts.Profile.ProjectID + req.AppName = opts.AppName + + var reqRoles []*models.Secrets20231128MongoDBRole + for _, r := range roles { + var castRole MongoDBRole + decoder, _ := mapstructure.NewDecoder(&mapstructure.DecoderConfig{WeaklyTypedInput: true, Result: &castRole}) + if err := decoder.Decode(r); err != nil { + return fmt.Errorf("invalid decoding to mongodbrole") + } + + reqRole := &models.Secrets20231128MongoDBRole{ + CollectionName: castRole.CollectionName, + RoleName: castRole.RoleName, + DatabaseName: castRole.DatabaseName, + } + reqRoles = append(reqRoles, reqRole) + } + req.Body = preview_secret_service.CreateMongoDBAtlasRotatingSecretBody{ + SecretName: rsc.SecretName, + RotationIntegrationName: rsc.RotationIntegrationName, + RotationPolicyName: rsc.RotationPolicyName, + MongodbGroupID: rsc.Details["group_id"].(string), + MongodbRoles: reqRoles, + } + _, err := opts.PreviewClient.CreateMongoDBAtlasRotatingSecret(req, nil) + if err != nil { + return fmt.Errorf("failed to create secret with name %q: %w", rsc.SecretName, err) + } + + fmt.Fprintln(opts.IO.Err()) + fmt.Fprintf(opts.IO.Err(), "%s Successfully created secret with name %q\n", opts.IO.ColorScheme().SuccessIcon(), rsc.SecretName) + } else { + return fmt.Errorf("invalid type") + } + return nil +} diff --git a/internal/commands/vaultsecrets/secrets/secrets.go b/internal/commands/vaultsecrets/secrets/secrets.go index 4a5f5fd9..4d1b3e69 100644 --- a/internal/commands/vaultsecrets/secrets/secrets.go +++ b/internal/commands/vaultsecrets/secrets/secrets.go @@ -44,6 +44,7 @@ func NewCmdSecrets(ctx *cmd.Context) *cmd.Command { } cmd.AddChild(NewCmdCreate(ctx, nil)) + cmd.AddChild(NewCmdCreateRotating(ctx, nil)) cmd.AddChild(NewCmdRead(ctx, nil)) cmd.AddChild(NewCmdDelete(ctx, nil)) cmd.AddChild(NewCmdList(ctx, nil)) diff --git a/internal/commands/vaultsecrets/vault_secrets.go b/internal/commands/vaultsecrets/vault_secrets.go index ab3b9612..e7b22cc4 100644 --- a/internal/commands/vaultsecrets/vault_secrets.go +++ b/internal/commands/vaultsecrets/vault_secrets.go @@ -5,6 +5,7 @@ package vaultsecrets import ( "github.com/hashicorp/hcp/internal/commands/vaultsecrets/apps" + "github.com/hashicorp/hcp/internal/commands/vaultsecrets/integrations" "github.com/hashicorp/hcp/internal/commands/vaultsecrets/run" "github.com/hashicorp/hcp/internal/commands/vaultsecrets/secrets" "github.com/hashicorp/hcp/internal/pkg/cmd" @@ -26,6 +27,7 @@ func NewCmdVaultSecrets(ctx *cmd.Context) *cmd.Command { cmd.AddChild(apps.NewCmdApps(ctx)) cmd.AddChild(secrets.NewCmdSecrets(ctx)) + cmd.AddChild(integrations.NewCmdIntegrations(ctx)) cmd.AddChild(run.NewCmdRun(ctx, nil)) return cmd } diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go index b85247bf..f1ef5f5e 100644 --- a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go @@ -170,80 +170,6 @@ func (_c *MockClientService_BillingAccountServiceCreateSetupIntent_Call) RunAndR return _c } -// BillingAccountServiceDeleteBillingAccount provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) BillingAccountServiceDeleteBillingAccount(params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error) { - _va := make([]interface{}, len(opts)) - for _i := range opts { - _va[_i] = opts[_i] - } - var _ca []interface{} - _ca = append(_ca, params, authInfo) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for BillingAccountServiceDeleteBillingAccount") - } - - var r0 *billing_account_service.BillingAccountServiceDeleteBillingAccountOK - var r1 error - if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error)); ok { - return rf(params, authInfo, opts...) - } - if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceDeleteBillingAccountOK); ok { - r0 = rf(params, authInfo, opts...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceDeleteBillingAccountOK) - } - } - - if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { - r1 = rf(params, authInfo, opts...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockClientService_BillingAccountServiceDeleteBillingAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceDeleteBillingAccount' -type MockClientService_BillingAccountServiceDeleteBillingAccount_Call struct { - *mock.Call -} - -// BillingAccountServiceDeleteBillingAccount is a helper method to define mock.On call -// - params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams -// - authInfo runtime.ClientAuthInfoWriter -// - opts ...billing_account_service.ClientOption -func (_e *MockClientService_Expecter) BillingAccountServiceDeleteBillingAccount(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { - return &MockClientService_BillingAccountServiceDeleteBillingAccount_Call{Call: _e.mock.On("BillingAccountServiceDeleteBillingAccount", - append([]interface{}{params, authInfo}, opts...)...)} -} - -func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) Run(run func(params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(billing_account_service.ClientOption) - } - } - run(args[0].(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) - }) - return _c -} - -func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) Return(_a0 *billing_account_service.BillingAccountServiceDeleteBillingAccountOK, _a1 error) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error)) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { - _c.Call.Return(run) - return _c -} - // BillingAccountServiceGet provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) BillingAccountServiceGet(params *billing_account_service.BillingAccountServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetOK, error) { _va := make([]interface{}, len(opts)) @@ -392,8 +318,8 @@ func (_c *MockClientService_BillingAccountServiceGetByProject_Call) RunAndReturn return _c } -// BillingAccountServiceList provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) BillingAccountServiceList(params *billing_account_service.BillingAccountServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error) { +// BillingAccountServiceGetPricingModelTransitions provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceGetPricingModelTransitions(params *billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -404,23 +330,23 @@ func (_m *MockClientService) BillingAccountServiceList(params *billing_account_s ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for BillingAccountServiceList") + panic("no return value specified for BillingAccountServiceGetPricingModelTransitions") } - var r0 *billing_account_service.BillingAccountServiceListOK + var r0 *billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK var r1 error - if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error)); ok { + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceListOK); ok { + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceListOK) + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK) } } - if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -429,21 +355,21 @@ func (_m *MockClientService) BillingAccountServiceList(params *billing_account_s return r0, r1 } -// MockClientService_BillingAccountServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceList' -type MockClientService_BillingAccountServiceList_Call struct { +// MockClientService_BillingAccountServiceGetPricingModelTransitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceGetPricingModelTransitions' +type MockClientService_BillingAccountServiceGetPricingModelTransitions_Call struct { *mock.Call } -// BillingAccountServiceList is a helper method to define mock.On call -// - params *billing_account_service.BillingAccountServiceListParams +// BillingAccountServiceGetPricingModelTransitions is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...billing_account_service.ClientOption -func (_e *MockClientService_Expecter) BillingAccountServiceList(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceList_Call { - return &MockClientService_BillingAccountServiceList_Call{Call: _e.mock.On("BillingAccountServiceList", +func (_e *MockClientService_Expecter) BillingAccountServiceGetPricingModelTransitions(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call { + return &MockClientService_BillingAccountServiceGetPricingModelTransitions_Call{Call: _e.mock.On("BillingAccountServiceGetPricingModelTransitions", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_BillingAccountServiceList_Call) Run(run func(params *billing_account_service.BillingAccountServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceList_Call { +func (_c *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call) Run(run func(params *billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -451,17 +377,17 @@ func (_c *MockClientService_BillingAccountServiceList_Call) Run(run func(params variadicArgs[i] = a.(billing_account_service.ClientOption) } } - run(args[0].(*billing_account_service.BillingAccountServiceListParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_BillingAccountServiceList_Call) Return(_a0 *billing_account_service.BillingAccountServiceListOK, _a1 error) *MockClientService_BillingAccountServiceList_Call { +func (_c *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call) Return(_a0 *billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK, _a1 error) *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_BillingAccountServiceList_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error)) *MockClientService_BillingAccountServiceList_Call { +func (_c *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceGetPricingModelTransitionsParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetPricingModelTransitionsOK, error)) *MockClientService_BillingAccountServiceGetPricingModelTransitions_Call { _c.Call.Return(run) return _c } diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go index a63fa049..c6645281 100644 --- a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go @@ -203,6 +203,80 @@ func (_c *MockClientService_StatementServiceGetStatement_Call) RunAndReturn(run return _c } +// StatementServiceGetStatementCSV provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) StatementServiceGetStatementCSV(params *statement_service.StatementServiceGetStatementCSVParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementCSVOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for StatementServiceGetStatementCSV") + } + + var r0 *statement_service.StatementServiceGetStatementCSVOK + var r1 error + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetStatementCSVParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementCSVOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetStatementCSVParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) *statement_service.StatementServiceGetStatementCSVOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*statement_service.StatementServiceGetStatementCSVOK) + } + } + + if rf, ok := ret.Get(1).(func(*statement_service.StatementServiceGetStatementCSVParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_StatementServiceGetStatementCSV_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatementServiceGetStatementCSV' +type MockClientService_StatementServiceGetStatementCSV_Call struct { + *mock.Call +} + +// StatementServiceGetStatementCSV is a helper method to define mock.On call +// - params *statement_service.StatementServiceGetStatementCSVParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...statement_service.ClientOption +func (_e *MockClientService_Expecter) StatementServiceGetStatementCSV(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_StatementServiceGetStatementCSV_Call { + return &MockClientService_StatementServiceGetStatementCSV_Call{Call: _e.mock.On("StatementServiceGetStatementCSV", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_StatementServiceGetStatementCSV_Call) Run(run func(params *statement_service.StatementServiceGetStatementCSVParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption)) *MockClientService_StatementServiceGetStatementCSV_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]statement_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(statement_service.ClientOption) + } + } + run(args[0].(*statement_service.StatementServiceGetStatementCSVParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_StatementServiceGetStatementCSV_Call) Return(_a0 *statement_service.StatementServiceGetStatementCSVOK, _a1 error) *MockClientService_StatementServiceGetStatementCSV_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_StatementServiceGetStatementCSV_Call) RunAndReturn(run func(*statement_service.StatementServiceGetStatementCSVParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementCSVOK, error)) *MockClientService_StatementServiceGetStatementCSV_Call { + _c.Call.Return(run) + return _c +} + // StatementServiceListStatements provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) StatementServiceListStatements(params *statement_service.StatementServiceListStatementsParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption) (*statement_service.StatementServiceListStatementsOK, error) { _va := make([]interface{}, len(opts)) diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service/mock_ClientService.go index 1d6c54b9..6b7485ec 100644 --- a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service/mock_ClientService.go +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-vault-secrets/preview/2023-11-28/client/secret_service/mock_ClientService.go @@ -170,6 +170,80 @@ func (_c *MockClientService_CompleteVercelInstallation_Call) RunAndReturn(run fu return _c } +// ConnectGitHubInstallation provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ConnectGitHubInstallation(params *secret_service.ConnectGitHubInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ConnectGitHubInstallationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ConnectGitHubInstallation") + } + + var r0 *secret_service.ConnectGitHubInstallationOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ConnectGitHubInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ConnectGitHubInstallationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ConnectGitHubInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ConnectGitHubInstallationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ConnectGitHubInstallationOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ConnectGitHubInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ConnectGitHubInstallation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectGitHubInstallation' +type MockClientService_ConnectGitHubInstallation_Call struct { + *mock.Call +} + +// ConnectGitHubInstallation is a helper method to define mock.On call +// - params *secret_service.ConnectGitHubInstallationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ConnectGitHubInstallation(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ConnectGitHubInstallation_Call { + return &MockClientService_ConnectGitHubInstallation_Call{Call: _e.mock.On("ConnectGitHubInstallation", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ConnectGitHubInstallation_Call) Run(run func(params *secret_service.ConnectGitHubInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ConnectGitHubInstallation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ConnectGitHubInstallationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ConnectGitHubInstallation_Call) Return(_a0 *secret_service.ConnectGitHubInstallationOK, _a1 error) *MockClientService_ConnectGitHubInstallation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ConnectGitHubInstallation_Call) RunAndReturn(run func(*secret_service.ConnectGitHubInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ConnectGitHubInstallationOK, error)) *MockClientService_ConnectGitHubInstallation_Call { + _c.Call.Return(run) + return _c +} + // CreateApp provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) CreateApp(params *secret_service.CreateAppParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateAppOK, error) { _va := make([]interface{}, len(opts)) @@ -614,6 +688,154 @@ func (_c *MockClientService_CreateAzureKvSyncIntegration_Call) RunAndReturn(run return _c } +// CreateGcpDynamicSecret provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateGcpDynamicSecret(params *secret_service.CreateGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateGcpDynamicSecretOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateGcpDynamicSecret") + } + + var r0 *secret_service.CreateGcpDynamicSecretOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.CreateGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateGcpDynamicSecretOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.CreateGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateGcpDynamicSecretOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.CreateGcpDynamicSecretOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.CreateGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_CreateGcpDynamicSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGcpDynamicSecret' +type MockClientService_CreateGcpDynamicSecret_Call struct { + *mock.Call +} + +// CreateGcpDynamicSecret is a helper method to define mock.On call +// - params *secret_service.CreateGcpDynamicSecretParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) CreateGcpDynamicSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateGcpDynamicSecret_Call { + return &MockClientService_CreateGcpDynamicSecret_Call{Call: _e.mock.On("CreateGcpDynamicSecret", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_CreateGcpDynamicSecret_Call) Run(run func(params *secret_service.CreateGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateGcpDynamicSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.CreateGcpDynamicSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_CreateGcpDynamicSecret_Call) Return(_a0 *secret_service.CreateGcpDynamicSecretOK, _a1 error) *MockClientService_CreateGcpDynamicSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_CreateGcpDynamicSecret_Call) RunAndReturn(run func(*secret_service.CreateGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateGcpDynamicSecretOK, error)) *MockClientService_CreateGcpDynamicSecret_Call { + _c.Call.Return(run) + return _c +} + +// CreateGcpIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateGcpIntegration(params *secret_service.CreateGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateGcpIntegrationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateGcpIntegration") + } + + var r0 *secret_service.CreateGcpIntegrationOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.CreateGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateGcpIntegrationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.CreateGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateGcpIntegrationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.CreateGcpIntegrationOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.CreateGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_CreateGcpIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGcpIntegration' +type MockClientService_CreateGcpIntegration_Call struct { + *mock.Call +} + +// CreateGcpIntegration is a helper method to define mock.On call +// - params *secret_service.CreateGcpIntegrationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) CreateGcpIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateGcpIntegration_Call { + return &MockClientService_CreateGcpIntegration_Call{Call: _e.mock.On("CreateGcpIntegration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_CreateGcpIntegration_Call) Run(run func(params *secret_service.CreateGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateGcpIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.CreateGcpIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_CreateGcpIntegration_Call) Return(_a0 *secret_service.CreateGcpIntegrationOK, _a1 error) *MockClientService_CreateGcpIntegration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_CreateGcpIntegration_Call) RunAndReturn(run func(*secret_service.CreateGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateGcpIntegrationOK, error)) *MockClientService_CreateGcpIntegration_Call { + _c.Call.Return(run) + return _c +} + // CreateGcpSmSyncIntegration provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) CreateGcpSmSyncIntegration(params *secret_service.CreateGcpSmSyncIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateGcpSmSyncIntegrationOK, error) { _va := make([]interface{}, len(opts)) @@ -836,8 +1058,8 @@ func (_c *MockClientService_CreateGhRepoSyncIntegration_Call) RunAndReturn(run f return _c } -// CreateMongoDBAtlasRotatingSecret provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) CreateMongoDBAtlasRotatingSecret(params *secret_service.CreateMongoDBAtlasRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error) { +// CreateMongoDBAtlasIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateMongoDBAtlasIntegration(params *secret_service.CreateMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -848,23 +1070,23 @@ func (_m *MockClientService) CreateMongoDBAtlasRotatingSecret(params *secret_ser ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for CreateMongoDBAtlasRotatingSecret") + panic("no return value specified for CreateMongoDBAtlasIntegration") } - var r0 *secret_service.CreateMongoDBAtlasRotatingSecretOK + var r0 *secret_service.CreateMongoDBAtlasIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateMongoDBAtlasRotatingSecretOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateMongoDBAtlasIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.CreateMongoDBAtlasRotatingSecretOK) + r0 = ret.Get(0).(*secret_service.CreateMongoDBAtlasIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.CreateMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -873,21 +1095,21 @@ func (_m *MockClientService) CreateMongoDBAtlasRotatingSecret(params *secret_ser return r0, r1 } -// MockClientService_CreateMongoDBAtlasRotatingSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMongoDBAtlasRotatingSecret' -type MockClientService_CreateMongoDBAtlasRotatingSecret_Call struct { +// MockClientService_CreateMongoDBAtlasIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMongoDBAtlasIntegration' +type MockClientService_CreateMongoDBAtlasIntegration_Call struct { *mock.Call } -// CreateMongoDBAtlasRotatingSecret is a helper method to define mock.On call -// - params *secret_service.CreateMongoDBAtlasRotatingSecretParams +// CreateMongoDBAtlasIntegration is a helper method to define mock.On call +// - params *secret_service.CreateMongoDBAtlasIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) CreateMongoDBAtlasRotatingSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { - return &MockClientService_CreateMongoDBAtlasRotatingSecret_Call{Call: _e.mock.On("CreateMongoDBAtlasRotatingSecret", +func (_e *MockClientService_Expecter) CreateMongoDBAtlasIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateMongoDBAtlasIntegration_Call { + return &MockClientService_CreateMongoDBAtlasIntegration_Call{Call: _e.mock.On("CreateMongoDBAtlasIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) Run(run func(params *secret_service.CreateMongoDBAtlasRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { +func (_c *MockClientService_CreateMongoDBAtlasIntegration_Call) Run(run func(params *secret_service.CreateMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateMongoDBAtlasIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -895,23 +1117,23 @@ func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) Run(run func( variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.CreateMongoDBAtlasRotatingSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.CreateMongoDBAtlasIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) Return(_a0 *secret_service.CreateMongoDBAtlasRotatingSecretOK, _a1 error) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { +func (_c *MockClientService_CreateMongoDBAtlasIntegration_Call) Return(_a0 *secret_service.CreateMongoDBAtlasIntegrationOK, _a1 error) *MockClientService_CreateMongoDBAtlasIntegration_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) RunAndReturn(run func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error)) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { +func (_c *MockClientService_CreateMongoDBAtlasIntegration_Call) RunAndReturn(run func(*secret_service.CreateMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasIntegrationOK, error)) *MockClientService_CreateMongoDBAtlasIntegration_Call { _c.Call.Return(run) return _c } -// CreateMongoDBAtlasRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) CreateMongoDBAtlasRotationIntegration(params *secret_service.CreateMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotationIntegrationOK, error) { +// CreateMongoDBAtlasRotatingSecret provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateMongoDBAtlasRotatingSecret(params *secret_service.CreateMongoDBAtlasRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -922,23 +1144,23 @@ func (_m *MockClientService) CreateMongoDBAtlasRotationIntegration(params *secre ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for CreateMongoDBAtlasRotationIntegration") + panic("no return value specified for CreateMongoDBAtlasRotatingSecret") } - var r0 *secret_service.CreateMongoDBAtlasRotationIntegrationOK + var r0 *secret_service.CreateMongoDBAtlasRotatingSecretOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateMongoDBAtlasRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateMongoDBAtlasRotatingSecretOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.CreateMongoDBAtlasRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.CreateMongoDBAtlasRotatingSecretOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.CreateMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -947,21 +1169,21 @@ func (_m *MockClientService) CreateMongoDBAtlasRotationIntegration(params *secre return r0, r1 } -// MockClientService_CreateMongoDBAtlasRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMongoDBAtlasRotationIntegration' -type MockClientService_CreateMongoDBAtlasRotationIntegration_Call struct { +// MockClientService_CreateMongoDBAtlasRotatingSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMongoDBAtlasRotatingSecret' +type MockClientService_CreateMongoDBAtlasRotatingSecret_Call struct { *mock.Call } -// CreateMongoDBAtlasRotationIntegration is a helper method to define mock.On call -// - params *secret_service.CreateMongoDBAtlasRotationIntegrationParams +// CreateMongoDBAtlasRotatingSecret is a helper method to define mock.On call +// - params *secret_service.CreateMongoDBAtlasRotatingSecretParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) CreateMongoDBAtlasRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateMongoDBAtlasRotationIntegration_Call { - return &MockClientService_CreateMongoDBAtlasRotationIntegration_Call{Call: _e.mock.On("CreateMongoDBAtlasRotationIntegration", +func (_e *MockClientService_Expecter) CreateMongoDBAtlasRotatingSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { + return &MockClientService_CreateMongoDBAtlasRotatingSecret_Call{Call: _e.mock.On("CreateMongoDBAtlasRotatingSecret", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_CreateMongoDBAtlasRotationIntegration_Call) Run(run func(params *secret_service.CreateMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) Run(run func(params *secret_service.CreateMongoDBAtlasRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -969,23 +1191,23 @@ func (_c *MockClientService_CreateMongoDBAtlasRotationIntegration_Call) Run(run variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.CreateMongoDBAtlasRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.CreateMongoDBAtlasRotatingSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_CreateMongoDBAtlasRotationIntegration_Call) Return(_a0 *secret_service.CreateMongoDBAtlasRotationIntegrationOK, _a1 error) *MockClientService_CreateMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) Return(_a0 *secret_service.CreateMongoDBAtlasRotatingSecretOK, _a1 error) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_CreateMongoDBAtlasRotationIntegration_Call) RunAndReturn(run func(*secret_service.CreateMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotationIntegrationOK, error)) *MockClientService_CreateMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_CreateMongoDBAtlasRotatingSecret_Call) RunAndReturn(run func(*secret_service.CreateMongoDBAtlasRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateMongoDBAtlasRotatingSecretOK, error)) *MockClientService_CreateMongoDBAtlasRotatingSecret_Call { _c.Call.Return(run) return _c } -// CreateTwilioRotatingSecret provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) CreateTwilioRotatingSecret(params *secret_service.CreateTwilioRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error) { +// CreateTwilioIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateTwilioIntegration(params *secret_service.CreateTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateTwilioIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -996,23 +1218,23 @@ func (_m *MockClientService) CreateTwilioRotatingSecret(params *secret_service.C ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for CreateTwilioRotatingSecret") + panic("no return value specified for CreateTwilioIntegration") } - var r0 *secret_service.CreateTwilioRotatingSecretOK + var r0 *secret_service.CreateTwilioIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateTwilioRotatingSecretOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateTwilioIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.CreateTwilioRotatingSecretOK) + r0 = ret.Get(0).(*secret_service.CreateTwilioIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.CreateTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -1021,21 +1243,21 @@ func (_m *MockClientService) CreateTwilioRotatingSecret(params *secret_service.C return r0, r1 } -// MockClientService_CreateTwilioRotatingSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTwilioRotatingSecret' -type MockClientService_CreateTwilioRotatingSecret_Call struct { +// MockClientService_CreateTwilioIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTwilioIntegration' +type MockClientService_CreateTwilioIntegration_Call struct { *mock.Call } -// CreateTwilioRotatingSecret is a helper method to define mock.On call -// - params *secret_service.CreateTwilioRotatingSecretParams +// CreateTwilioIntegration is a helper method to define mock.On call +// - params *secret_service.CreateTwilioIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) CreateTwilioRotatingSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateTwilioRotatingSecret_Call { - return &MockClientService_CreateTwilioRotatingSecret_Call{Call: _e.mock.On("CreateTwilioRotatingSecret", +func (_e *MockClientService_Expecter) CreateTwilioIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateTwilioIntegration_Call { + return &MockClientService_CreateTwilioIntegration_Call{Call: _e.mock.On("CreateTwilioIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_CreateTwilioRotatingSecret_Call) Run(run func(params *secret_service.CreateTwilioRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateTwilioRotatingSecret_Call { +func (_c *MockClientService_CreateTwilioIntegration_Call) Run(run func(params *secret_service.CreateTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateTwilioIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -1043,23 +1265,23 @@ func (_c *MockClientService_CreateTwilioRotatingSecret_Call) Run(run func(params variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.CreateTwilioRotatingSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.CreateTwilioIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_CreateTwilioRotatingSecret_Call) Return(_a0 *secret_service.CreateTwilioRotatingSecretOK, _a1 error) *MockClientService_CreateTwilioRotatingSecret_Call { +func (_c *MockClientService_CreateTwilioIntegration_Call) Return(_a0 *secret_service.CreateTwilioIntegrationOK, _a1 error) *MockClientService_CreateTwilioIntegration_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_CreateTwilioRotatingSecret_Call) RunAndReturn(run func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error)) *MockClientService_CreateTwilioRotatingSecret_Call { +func (_c *MockClientService_CreateTwilioIntegration_Call) RunAndReturn(run func(*secret_service.CreateTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioIntegrationOK, error)) *MockClientService_CreateTwilioIntegration_Call { _c.Call.Return(run) return _c } -// CreateTwilioRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) CreateTwilioRotationIntegration(params *secret_service.CreateTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateTwilioRotationIntegrationOK, error) { +// CreateTwilioRotatingSecret provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) CreateTwilioRotatingSecret(params *secret_service.CreateTwilioRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -1070,23 +1292,23 @@ func (_m *MockClientService) CreateTwilioRotationIntegration(params *secret_serv ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for CreateTwilioRotationIntegration") + panic("no return value specified for CreateTwilioRotatingSecret") } - var r0 *secret_service.CreateTwilioRotationIntegrationOK + var r0 *secret_service.CreateTwilioRotatingSecretOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateTwilioRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.CreateTwilioRotatingSecretOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.CreateTwilioRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.CreateTwilioRotatingSecretOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.CreateTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -1095,21 +1317,21 @@ func (_m *MockClientService) CreateTwilioRotationIntegration(params *secret_serv return r0, r1 } -// MockClientService_CreateTwilioRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTwilioRotationIntegration' -type MockClientService_CreateTwilioRotationIntegration_Call struct { +// MockClientService_CreateTwilioRotatingSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTwilioRotatingSecret' +type MockClientService_CreateTwilioRotatingSecret_Call struct { *mock.Call } -// CreateTwilioRotationIntegration is a helper method to define mock.On call -// - params *secret_service.CreateTwilioRotationIntegrationParams +// CreateTwilioRotatingSecret is a helper method to define mock.On call +// - params *secret_service.CreateTwilioRotatingSecretParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) CreateTwilioRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateTwilioRotationIntegration_Call { - return &MockClientService_CreateTwilioRotationIntegration_Call{Call: _e.mock.On("CreateTwilioRotationIntegration", +func (_e *MockClientService_Expecter) CreateTwilioRotatingSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_CreateTwilioRotatingSecret_Call { + return &MockClientService_CreateTwilioRotatingSecret_Call{Call: _e.mock.On("CreateTwilioRotatingSecret", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_CreateTwilioRotationIntegration_Call) Run(run func(params *secret_service.CreateTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateTwilioRotationIntegration_Call { +func (_c *MockClientService_CreateTwilioRotatingSecret_Call) Run(run func(params *secret_service.CreateTwilioRotatingSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_CreateTwilioRotatingSecret_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -1117,17 +1339,17 @@ func (_c *MockClientService_CreateTwilioRotationIntegration_Call) Run(run func(p variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.CreateTwilioRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.CreateTwilioRotatingSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_CreateTwilioRotationIntegration_Call) Return(_a0 *secret_service.CreateTwilioRotationIntegrationOK, _a1 error) *MockClientService_CreateTwilioRotationIntegration_Call { +func (_c *MockClientService_CreateTwilioRotatingSecret_Call) Return(_a0 *secret_service.CreateTwilioRotatingSecretOK, _a1 error) *MockClientService_CreateTwilioRotatingSecret_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_CreateTwilioRotationIntegration_Call) RunAndReturn(run func(*secret_service.CreateTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotationIntegrationOK, error)) *MockClientService_CreateTwilioRotationIntegration_Call { +func (_c *MockClientService_CreateTwilioRotatingSecret_Call) RunAndReturn(run func(*secret_service.CreateTwilioRotatingSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.CreateTwilioRotatingSecretOK, error)) *MockClientService_CreateTwilioRotatingSecret_Call { _c.Call.Return(run) return _c } @@ -1576,8 +1798,8 @@ func (_c *MockClientService_DeleteAwsIntegration_Call) RunAndReturn(run func(*se return _c } -// DeleteMongoDBAtlasRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) DeleteMongoDBAtlasRotationIntegration(params *secret_service.DeleteMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasRotationIntegrationOK, error) { +// DeleteGcpDynamicSecret provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) DeleteGcpDynamicSecret(params *secret_service.DeleteGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteGcpDynamicSecretOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -1588,23 +1810,23 @@ func (_m *MockClientService) DeleteMongoDBAtlasRotationIntegration(params *secre ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for DeleteMongoDBAtlasRotationIntegration") + panic("no return value specified for DeleteGcpDynamicSecret") } - var r0 *secret_service.DeleteMongoDBAtlasRotationIntegrationOK + var r0 *secret_service.DeleteGcpDynamicSecretOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.DeleteMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteGcpDynamicSecretOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.DeleteMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteMongoDBAtlasRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteGcpDynamicSecretOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.DeleteMongoDBAtlasRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.DeleteGcpDynamicSecretOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.DeleteMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.DeleteGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -1613,21 +1835,21 @@ func (_m *MockClientService) DeleteMongoDBAtlasRotationIntegration(params *secre return r0, r1 } -// MockClientService_DeleteMongoDBAtlasRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMongoDBAtlasRotationIntegration' -type MockClientService_DeleteMongoDBAtlasRotationIntegration_Call struct { +// MockClientService_DeleteGcpDynamicSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGcpDynamicSecret' +type MockClientService_DeleteGcpDynamicSecret_Call struct { *mock.Call } -// DeleteMongoDBAtlasRotationIntegration is a helper method to define mock.On call -// - params *secret_service.DeleteMongoDBAtlasRotationIntegrationParams +// DeleteGcpDynamicSecret is a helper method to define mock.On call +// - params *secret_service.DeleteGcpDynamicSecretParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) DeleteMongoDBAtlasRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call { - return &MockClientService_DeleteMongoDBAtlasRotationIntegration_Call{Call: _e.mock.On("DeleteMongoDBAtlasRotationIntegration", +func (_e *MockClientService_Expecter) DeleteGcpDynamicSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteGcpDynamicSecret_Call { + return &MockClientService_DeleteGcpDynamicSecret_Call{Call: _e.mock.On("DeleteGcpDynamicSecret", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call) Run(run func(params *secret_service.DeleteMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_DeleteGcpDynamicSecret_Call) Run(run func(params *secret_service.DeleteGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteGcpDynamicSecret_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -1635,23 +1857,23 @@ func (_c *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call) Run(run variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.DeleteMongoDBAtlasRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.DeleteGcpDynamicSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call) Return(_a0 *secret_service.DeleteMongoDBAtlasRotationIntegrationOK, _a1 error) *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_DeleteGcpDynamicSecret_Call) Return(_a0 *secret_service.DeleteGcpDynamicSecretOK, _a1 error) *MockClientService_DeleteGcpDynamicSecret_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call) RunAndReturn(run func(*secret_service.DeleteMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasRotationIntegrationOK, error)) *MockClientService_DeleteMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_DeleteGcpDynamicSecret_Call) RunAndReturn(run func(*secret_service.DeleteGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteGcpDynamicSecretOK, error)) *MockClientService_DeleteGcpDynamicSecret_Call { _c.Call.Return(run) return _c } -// DeleteSyncInstallation provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) DeleteSyncInstallation(params *secret_service.DeleteSyncInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteSyncInstallationOK, error) { +// DeleteGcpIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) DeleteGcpIntegration(params *secret_service.DeleteGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteGcpIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -1662,23 +1884,23 @@ func (_m *MockClientService) DeleteSyncInstallation(params *secret_service.Delet ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for DeleteSyncInstallation") + panic("no return value specified for DeleteGcpIntegration") } - var r0 *secret_service.DeleteSyncInstallationOK + var r0 *secret_service.DeleteGcpIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteSyncInstallationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteGcpIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteSyncInstallationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteGcpIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.DeleteSyncInstallationOK) + r0 = ret.Get(0).(*secret_service.DeleteGcpIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.DeleteGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -1687,21 +1909,21 @@ func (_m *MockClientService) DeleteSyncInstallation(params *secret_service.Delet return r0, r1 } -// MockClientService_DeleteSyncInstallation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSyncInstallation' -type MockClientService_DeleteSyncInstallation_Call struct { +// MockClientService_DeleteGcpIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGcpIntegration' +type MockClientService_DeleteGcpIntegration_Call struct { *mock.Call } -// DeleteSyncInstallation is a helper method to define mock.On call -// - params *secret_service.DeleteSyncInstallationParams +// DeleteGcpIntegration is a helper method to define mock.On call +// - params *secret_service.DeleteGcpIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) DeleteSyncInstallation(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteSyncInstallation_Call { - return &MockClientService_DeleteSyncInstallation_Call{Call: _e.mock.On("DeleteSyncInstallation", +func (_e *MockClientService_Expecter) DeleteGcpIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteGcpIntegration_Call { + return &MockClientService_DeleteGcpIntegration_Call{Call: _e.mock.On("DeleteGcpIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_DeleteSyncInstallation_Call) Run(run func(params *secret_service.DeleteSyncInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteSyncInstallation_Call { +func (_c *MockClientService_DeleteGcpIntegration_Call) Run(run func(params *secret_service.DeleteGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteGcpIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -1709,7 +1931,155 @@ func (_c *MockClientService_DeleteSyncInstallation_Call) Run(run func(params *se variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.DeleteSyncInstallationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.DeleteGcpIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_DeleteGcpIntegration_Call) Return(_a0 *secret_service.DeleteGcpIntegrationOK, _a1 error) *MockClientService_DeleteGcpIntegration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_DeleteGcpIntegration_Call) RunAndReturn(run func(*secret_service.DeleteGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteGcpIntegrationOK, error)) *MockClientService_DeleteGcpIntegration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteMongoDBAtlasIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) DeleteMongoDBAtlasIntegration(params *secret_service.DeleteMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasIntegrationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteMongoDBAtlasIntegration") + } + + var r0 *secret_service.DeleteMongoDBAtlasIntegrationOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.DeleteMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasIntegrationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.DeleteMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteMongoDBAtlasIntegrationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.DeleteMongoDBAtlasIntegrationOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.DeleteMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_DeleteMongoDBAtlasIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMongoDBAtlasIntegration' +type MockClientService_DeleteMongoDBAtlasIntegration_Call struct { + *mock.Call +} + +// DeleteMongoDBAtlasIntegration is a helper method to define mock.On call +// - params *secret_service.DeleteMongoDBAtlasIntegrationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) DeleteMongoDBAtlasIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteMongoDBAtlasIntegration_Call { + return &MockClientService_DeleteMongoDBAtlasIntegration_Call{Call: _e.mock.On("DeleteMongoDBAtlasIntegration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_DeleteMongoDBAtlasIntegration_Call) Run(run func(params *secret_service.DeleteMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteMongoDBAtlasIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.DeleteMongoDBAtlasIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_DeleteMongoDBAtlasIntegration_Call) Return(_a0 *secret_service.DeleteMongoDBAtlasIntegrationOK, _a1 error) *MockClientService_DeleteMongoDBAtlasIntegration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_DeleteMongoDBAtlasIntegration_Call) RunAndReturn(run func(*secret_service.DeleteMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteMongoDBAtlasIntegrationOK, error)) *MockClientService_DeleteMongoDBAtlasIntegration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteSyncInstallation provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) DeleteSyncInstallation(params *secret_service.DeleteSyncInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteSyncInstallationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteSyncInstallation") + } + + var r0 *secret_service.DeleteSyncInstallationOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteSyncInstallationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteSyncInstallationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.DeleteSyncInstallationOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.DeleteSyncInstallationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_DeleteSyncInstallation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSyncInstallation' +type MockClientService_DeleteSyncInstallation_Call struct { + *mock.Call +} + +// DeleteSyncInstallation is a helper method to define mock.On call +// - params *secret_service.DeleteSyncInstallationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) DeleteSyncInstallation(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteSyncInstallation_Call { + return &MockClientService_DeleteSyncInstallation_Call{Call: _e.mock.On("DeleteSyncInstallation", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_DeleteSyncInstallation_Call) Run(run func(params *secret_service.DeleteSyncInstallationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteSyncInstallation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.DeleteSyncInstallationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } @@ -1798,8 +2168,8 @@ func (_c *MockClientService_DeleteSyncIntegration_Call) RunAndReturn(run func(*s return _c } -// DeleteTwilioRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) DeleteTwilioRotationIntegration(params *secret_service.DeleteTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteTwilioRotationIntegrationOK, error) { +// DeleteTwilioIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) DeleteTwilioIntegration(params *secret_service.DeleteTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.DeleteTwilioIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -1810,23 +2180,23 @@ func (_m *MockClientService) DeleteTwilioRotationIntegration(params *secret_serv ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for DeleteTwilioRotationIntegration") + panic("no return value specified for DeleteTwilioIntegration") } - var r0 *secret_service.DeleteTwilioRotationIntegrationOK + var r0 *secret_service.DeleteTwilioIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.DeleteTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteTwilioRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteTwilioIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.DeleteTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteTwilioRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.DeleteTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.DeleteTwilioIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.DeleteTwilioRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.DeleteTwilioIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.DeleteTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.DeleteTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -1835,21 +2205,21 @@ func (_m *MockClientService) DeleteTwilioRotationIntegration(params *secret_serv return r0, r1 } -// MockClientService_DeleteTwilioRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTwilioRotationIntegration' -type MockClientService_DeleteTwilioRotationIntegration_Call struct { +// MockClientService_DeleteTwilioIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTwilioIntegration' +type MockClientService_DeleteTwilioIntegration_Call struct { *mock.Call } -// DeleteTwilioRotationIntegration is a helper method to define mock.On call -// - params *secret_service.DeleteTwilioRotationIntegrationParams +// DeleteTwilioIntegration is a helper method to define mock.On call +// - params *secret_service.DeleteTwilioIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) DeleteTwilioRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteTwilioRotationIntegration_Call { - return &MockClientService_DeleteTwilioRotationIntegration_Call{Call: _e.mock.On("DeleteTwilioRotationIntegration", +func (_e *MockClientService_Expecter) DeleteTwilioIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_DeleteTwilioIntegration_Call { + return &MockClientService_DeleteTwilioIntegration_Call{Call: _e.mock.On("DeleteTwilioIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_DeleteTwilioRotationIntegration_Call) Run(run func(params *secret_service.DeleteTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteTwilioRotationIntegration_Call { +func (_c *MockClientService_DeleteTwilioIntegration_Call) Run(run func(params *secret_service.DeleteTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_DeleteTwilioIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -1857,17 +2227,17 @@ func (_c *MockClientService_DeleteTwilioRotationIntegration_Call) Run(run func(p variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.DeleteTwilioRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.DeleteTwilioIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_DeleteTwilioRotationIntegration_Call) Return(_a0 *secret_service.DeleteTwilioRotationIntegrationOK, _a1 error) *MockClientService_DeleteTwilioRotationIntegration_Call { +func (_c *MockClientService_DeleteTwilioIntegration_Call) Return(_a0 *secret_service.DeleteTwilioIntegrationOK, _a1 error) *MockClientService_DeleteTwilioIntegration_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_DeleteTwilioRotationIntegration_Call) RunAndReturn(run func(*secret_service.DeleteTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteTwilioRotationIntegrationOK, error)) *MockClientService_DeleteTwilioRotationIntegration_Call { +func (_c *MockClientService_DeleteTwilioIntegration_Call) RunAndReturn(run func(*secret_service.DeleteTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.DeleteTwilioIntegrationOK, error)) *MockClientService_DeleteTwilioIntegration_Call { _c.Call.Return(run) return _c } @@ -2316,8 +2686,8 @@ func (_c *MockClientService_GetAwsIntegration_Call) RunAndReturn(run func(*secre return _c } -// GetGitHubEnvironments provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetGitHubEnvironments(params *secret_service.GetGitHubEnvironmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error) { +// GetGcpDynamicSecret provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetGcpDynamicSecret(params *secret_service.GetGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGcpDynamicSecretOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2328,23 +2698,23 @@ func (_m *MockClientService) GetGitHubEnvironments(params *secret_service.GetGit ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetGitHubEnvironments") + panic("no return value specified for GetGcpDynamicSecret") } - var r0 *secret_service.GetGitHubEnvironmentsOK + var r0 *secret_service.GetGcpDynamicSecretOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGcpDynamicSecretOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubEnvironmentsOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGcpDynamicSecretOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetGitHubEnvironmentsOK) + r0 = ret.Get(0).(*secret_service.GetGcpDynamicSecretOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2353,21 +2723,21 @@ func (_m *MockClientService) GetGitHubEnvironments(params *secret_service.GetGit return r0, r1 } -// MockClientService_GetGitHubEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubEnvironments' -type MockClientService_GetGitHubEnvironments_Call struct { +// MockClientService_GetGcpDynamicSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGcpDynamicSecret' +type MockClientService_GetGcpDynamicSecret_Call struct { *mock.Call } -// GetGitHubEnvironments is a helper method to define mock.On call -// - params *secret_service.GetGitHubEnvironmentsParams +// GetGcpDynamicSecret is a helper method to define mock.On call +// - params *secret_service.GetGcpDynamicSecretParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetGitHubEnvironments(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubEnvironments_Call { - return &MockClientService_GetGitHubEnvironments_Call{Call: _e.mock.On("GetGitHubEnvironments", +func (_e *MockClientService_Expecter) GetGcpDynamicSecret(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGcpDynamicSecret_Call { + return &MockClientService_GetGcpDynamicSecret_Call{Call: _e.mock.On("GetGcpDynamicSecret", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetGitHubEnvironments_Call) Run(run func(params *secret_service.GetGitHubEnvironmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubEnvironments_Call { +func (_c *MockClientService_GetGcpDynamicSecret_Call) Run(run func(params *secret_service.GetGcpDynamicSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGcpDynamicSecret_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2375,23 +2745,23 @@ func (_c *MockClientService_GetGitHubEnvironments_Call) Run(run func(params *sec variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetGitHubEnvironmentsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetGcpDynamicSecretParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetGitHubEnvironments_Call) Return(_a0 *secret_service.GetGitHubEnvironmentsOK, _a1 error) *MockClientService_GetGitHubEnvironments_Call { +func (_c *MockClientService_GetGcpDynamicSecret_Call) Return(_a0 *secret_service.GetGcpDynamicSecretOK, _a1 error) *MockClientService_GetGcpDynamicSecret_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetGitHubEnvironments_Call) RunAndReturn(run func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error)) *MockClientService_GetGitHubEnvironments_Call { +func (_c *MockClientService_GetGcpDynamicSecret_Call) RunAndReturn(run func(*secret_service.GetGcpDynamicSecretParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGcpDynamicSecretOK, error)) *MockClientService_GetGcpDynamicSecret_Call { _c.Call.Return(run) return _c } -// GetGitHubInstallLinks provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetGitHubInstallLinks(params *secret_service.GetGitHubInstallLinksParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error) { +// GetGcpIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetGcpIntegration(params *secret_service.GetGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGcpIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2402,23 +2772,23 @@ func (_m *MockClientService) GetGitHubInstallLinks(params *secret_service.GetGit ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetGitHubInstallLinks") + panic("no return value specified for GetGcpIntegration") } - var r0 *secret_service.GetGitHubInstallLinksOK + var r0 *secret_service.GetGcpIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGcpIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubInstallLinksOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGcpIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetGitHubInstallLinksOK) + r0 = ret.Get(0).(*secret_service.GetGcpIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2427,21 +2797,21 @@ func (_m *MockClientService) GetGitHubInstallLinks(params *secret_service.GetGit return r0, r1 } -// MockClientService_GetGitHubInstallLinks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubInstallLinks' -type MockClientService_GetGitHubInstallLinks_Call struct { +// MockClientService_GetGcpIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGcpIntegration' +type MockClientService_GetGcpIntegration_Call struct { *mock.Call } -// GetGitHubInstallLinks is a helper method to define mock.On call -// - params *secret_service.GetGitHubInstallLinksParams +// GetGcpIntegration is a helper method to define mock.On call +// - params *secret_service.GetGcpIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetGitHubInstallLinks(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubInstallLinks_Call { - return &MockClientService_GetGitHubInstallLinks_Call{Call: _e.mock.On("GetGitHubInstallLinks", +func (_e *MockClientService_Expecter) GetGcpIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGcpIntegration_Call { + return &MockClientService_GetGcpIntegration_Call{Call: _e.mock.On("GetGcpIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetGitHubInstallLinks_Call) Run(run func(params *secret_service.GetGitHubInstallLinksParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubInstallLinks_Call { +func (_c *MockClientService_GetGcpIntegration_Call) Run(run func(params *secret_service.GetGcpIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGcpIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2449,23 +2819,23 @@ func (_c *MockClientService_GetGitHubInstallLinks_Call) Run(run func(params *sec variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetGitHubInstallLinksParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetGcpIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetGitHubInstallLinks_Call) Return(_a0 *secret_service.GetGitHubInstallLinksOK, _a1 error) *MockClientService_GetGitHubInstallLinks_Call { +func (_c *MockClientService_GetGcpIntegration_Call) Return(_a0 *secret_service.GetGcpIntegrationOK, _a1 error) *MockClientService_GetGcpIntegration_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetGitHubInstallLinks_Call) RunAndReturn(run func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error)) *MockClientService_GetGitHubInstallLinks_Call { +func (_c *MockClientService_GetGcpIntegration_Call) RunAndReturn(run func(*secret_service.GetGcpIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGcpIntegrationOK, error)) *MockClientService_GetGcpIntegration_Call { _c.Call.Return(run) return _c } -// GetGitHubRepositories provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetGitHubRepositories(params *secret_service.GetGitHubRepositoriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error) { +// GetGitHubEnvironments provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetGitHubEnvironments(params *secret_service.GetGitHubEnvironmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2476,23 +2846,23 @@ func (_m *MockClientService) GetGitHubRepositories(params *secret_service.GetGit ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetGitHubRepositories") + panic("no return value specified for GetGitHubEnvironments") } - var r0 *secret_service.GetGitHubRepositoriesOK + var r0 *secret_service.GetGitHubEnvironmentsOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubRepositoriesOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubEnvironmentsOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetGitHubRepositoriesOK) + r0 = ret.Get(0).(*secret_service.GetGitHubEnvironmentsOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2501,21 +2871,21 @@ func (_m *MockClientService) GetGitHubRepositories(params *secret_service.GetGit return r0, r1 } -// MockClientService_GetGitHubRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubRepositories' -type MockClientService_GetGitHubRepositories_Call struct { +// MockClientService_GetGitHubEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubEnvironments' +type MockClientService_GetGitHubEnvironments_Call struct { *mock.Call } -// GetGitHubRepositories is a helper method to define mock.On call -// - params *secret_service.GetGitHubRepositoriesParams +// GetGitHubEnvironments is a helper method to define mock.On call +// - params *secret_service.GetGitHubEnvironmentsParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetGitHubRepositories(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubRepositories_Call { - return &MockClientService_GetGitHubRepositories_Call{Call: _e.mock.On("GetGitHubRepositories", +func (_e *MockClientService_Expecter) GetGitHubEnvironments(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubEnvironments_Call { + return &MockClientService_GetGitHubEnvironments_Call{Call: _e.mock.On("GetGitHubEnvironments", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetGitHubRepositories_Call) Run(run func(params *secret_service.GetGitHubRepositoriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubRepositories_Call { +func (_c *MockClientService_GetGitHubEnvironments_Call) Run(run func(params *secret_service.GetGitHubEnvironmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubEnvironments_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2523,23 +2893,23 @@ func (_c *MockClientService_GetGitHubRepositories_Call) Run(run func(params *sec variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetGitHubRepositoriesParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetGitHubEnvironmentsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetGitHubRepositories_Call) Return(_a0 *secret_service.GetGitHubRepositoriesOK, _a1 error) *MockClientService_GetGitHubRepositories_Call { +func (_c *MockClientService_GetGitHubEnvironments_Call) Return(_a0 *secret_service.GetGitHubEnvironmentsOK, _a1 error) *MockClientService_GetGitHubEnvironments_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetGitHubRepositories_Call) RunAndReturn(run func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error)) *MockClientService_GetGitHubRepositories_Call { +func (_c *MockClientService_GetGitHubEnvironments_Call) RunAndReturn(run func(*secret_service.GetGitHubEnvironmentsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubEnvironmentsOK, error)) *MockClientService_GetGitHubEnvironments_Call { _c.Call.Return(run) return _c } -// GetMongoDBAtlasRotatingSecretConfig provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetMongoDBAtlasRotatingSecretConfig(params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error) { +// GetGitHubInstallLinks provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetGitHubInstallLinks(params *secret_service.GetGitHubInstallLinksParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2550,23 +2920,23 @@ func (_m *MockClientService) GetMongoDBAtlasRotatingSecretConfig(params *secret_ ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetMongoDBAtlasRotatingSecretConfig") + panic("no return value specified for GetGitHubInstallLinks") } - var r0 *secret_service.GetMongoDBAtlasRotatingSecretConfigOK + var r0 *secret_service.GetGitHubInstallLinksOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetMongoDBAtlasRotatingSecretConfigOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubInstallLinksOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetMongoDBAtlasRotatingSecretConfigOK) + r0 = ret.Get(0).(*secret_service.GetGitHubInstallLinksOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2575,21 +2945,21 @@ func (_m *MockClientService) GetMongoDBAtlasRotatingSecretConfig(params *secret_ return r0, r1 } -// MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMongoDBAtlasRotatingSecretConfig' -type MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call struct { +// MockClientService_GetGitHubInstallLinks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubInstallLinks' +type MockClientService_GetGitHubInstallLinks_Call struct { *mock.Call } -// GetMongoDBAtlasRotatingSecretConfig is a helper method to define mock.On call -// - params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams +// GetGitHubInstallLinks is a helper method to define mock.On call +// - params *secret_service.GetGitHubInstallLinksParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetMongoDBAtlasRotatingSecretConfig(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { - return &MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call{Call: _e.mock.On("GetMongoDBAtlasRotatingSecretConfig", +func (_e *MockClientService_Expecter) GetGitHubInstallLinks(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubInstallLinks_Call { + return &MockClientService_GetGitHubInstallLinks_Call{Call: _e.mock.On("GetGitHubInstallLinks", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) Run(run func(params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { +func (_c *MockClientService_GetGitHubInstallLinks_Call) Run(run func(params *secret_service.GetGitHubInstallLinksParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubInstallLinks_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2597,23 +2967,23 @@ func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) Run(run fu variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetGitHubInstallLinksParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) Return(_a0 *secret_service.GetMongoDBAtlasRotatingSecretConfigOK, _a1 error) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { +func (_c *MockClientService_GetGitHubInstallLinks_Call) Return(_a0 *secret_service.GetGitHubInstallLinksOK, _a1 error) *MockClientService_GetGitHubInstallLinks_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) RunAndReturn(run func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error)) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { +func (_c *MockClientService_GetGitHubInstallLinks_Call) RunAndReturn(run func(*secret_service.GetGitHubInstallLinksParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubInstallLinksOK, error)) *MockClientService_GetGitHubInstallLinks_Call { _c.Call.Return(run) return _c } -// GetMongoDBAtlasRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetMongoDBAtlasRotationIntegration(params *secret_service.GetMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotationIntegrationOK, error) { +// GetGitHubRepositories provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetGitHubRepositories(params *secret_service.GetGitHubRepositoriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2624,23 +2994,23 @@ func (_m *MockClientService) GetMongoDBAtlasRotationIntegration(params *secret_s ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetMongoDBAtlasRotationIntegration") + panic("no return value specified for GetGitHubRepositories") } - var r0 *secret_service.GetMongoDBAtlasRotationIntegrationOK + var r0 *secret_service.GetGitHubRepositoriesOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetMongoDBAtlasRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetGitHubRepositoriesOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetMongoDBAtlasRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.GetGitHubRepositoriesOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2649,21 +3019,21 @@ func (_m *MockClientService) GetMongoDBAtlasRotationIntegration(params *secret_s return r0, r1 } -// MockClientService_GetMongoDBAtlasRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMongoDBAtlasRotationIntegration' -type MockClientService_GetMongoDBAtlasRotationIntegration_Call struct { +// MockClientService_GetGitHubRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGitHubRepositories' +type MockClientService_GetGitHubRepositories_Call struct { *mock.Call } -// GetMongoDBAtlasRotationIntegration is a helper method to define mock.On call -// - params *secret_service.GetMongoDBAtlasRotationIntegrationParams +// GetGitHubRepositories is a helper method to define mock.On call +// - params *secret_service.GetGitHubRepositoriesParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetMongoDBAtlasRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetMongoDBAtlasRotationIntegration_Call { - return &MockClientService_GetMongoDBAtlasRotationIntegration_Call{Call: _e.mock.On("GetMongoDBAtlasRotationIntegration", +func (_e *MockClientService_Expecter) GetGitHubRepositories(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetGitHubRepositories_Call { + return &MockClientService_GetGitHubRepositories_Call{Call: _e.mock.On("GetGitHubRepositories", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetMongoDBAtlasRotationIntegration_Call) Run(run func(params *secret_service.GetMongoDBAtlasRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_GetGitHubRepositories_Call) Run(run func(params *secret_service.GetGitHubRepositoriesParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetGitHubRepositories_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2671,23 +3041,171 @@ func (_c *MockClientService_GetMongoDBAtlasRotationIntegration_Call) Run(run fun variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetMongoDBAtlasRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetGitHubRepositoriesParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetMongoDBAtlasRotationIntegration_Call) Return(_a0 *secret_service.GetMongoDBAtlasRotationIntegrationOK, _a1 error) *MockClientService_GetMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_GetGitHubRepositories_Call) Return(_a0 *secret_service.GetGitHubRepositoriesOK, _a1 error) *MockClientService_GetGitHubRepositories_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetMongoDBAtlasRotationIntegration_Call) RunAndReturn(run func(*secret_service.GetMongoDBAtlasRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotationIntegrationOK, error)) *MockClientService_GetMongoDBAtlasRotationIntegration_Call { +func (_c *MockClientService_GetGitHubRepositories_Call) RunAndReturn(run func(*secret_service.GetGitHubRepositoriesParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetGitHubRepositoriesOK, error)) *MockClientService_GetGitHubRepositories_Call { _c.Call.Return(run) return _c } -// GetRotatingSecretState provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetRotatingSecretState(params *secret_service.GetRotatingSecretStateParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetRotatingSecretStateOK, error) { +// GetMongoDBAtlasIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetMongoDBAtlasIntegration(params *secret_service.GetMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasIntegrationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetMongoDBAtlasIntegration") + } + + var r0 *secret_service.GetMongoDBAtlasIntegrationOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasIntegrationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetMongoDBAtlasIntegrationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.GetMongoDBAtlasIntegrationOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.GetMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GetMongoDBAtlasIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMongoDBAtlasIntegration' +type MockClientService_GetMongoDBAtlasIntegration_Call struct { + *mock.Call +} + +// GetMongoDBAtlasIntegration is a helper method to define mock.On call +// - params *secret_service.GetMongoDBAtlasIntegrationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) GetMongoDBAtlasIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetMongoDBAtlasIntegration_Call { + return &MockClientService_GetMongoDBAtlasIntegration_Call{Call: _e.mock.On("GetMongoDBAtlasIntegration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GetMongoDBAtlasIntegration_Call) Run(run func(params *secret_service.GetMongoDBAtlasIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetMongoDBAtlasIntegration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.GetMongoDBAtlasIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GetMongoDBAtlasIntegration_Call) Return(_a0 *secret_service.GetMongoDBAtlasIntegrationOK, _a1 error) *MockClientService_GetMongoDBAtlasIntegration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GetMongoDBAtlasIntegration_Call) RunAndReturn(run func(*secret_service.GetMongoDBAtlasIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasIntegrationOK, error)) *MockClientService_GetMongoDBAtlasIntegration_Call { + _c.Call.Return(run) + return _c +} + +// GetMongoDBAtlasRotatingSecretConfig provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetMongoDBAtlasRotatingSecretConfig(params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetMongoDBAtlasRotatingSecretConfig") + } + + var r0 *secret_service.GetMongoDBAtlasRotatingSecretConfigOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetMongoDBAtlasRotatingSecretConfigOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.GetMongoDBAtlasRotatingSecretConfigOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMongoDBAtlasRotatingSecretConfig' +type MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call struct { + *mock.Call +} + +// GetMongoDBAtlasRotatingSecretConfig is a helper method to define mock.On call +// - params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) GetMongoDBAtlasRotatingSecretConfig(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { + return &MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call{Call: _e.mock.On("GetMongoDBAtlasRotatingSecretConfig", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) Run(run func(params *secret_service.GetMongoDBAtlasRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) Return(_a0 *secret_service.GetMongoDBAtlasRotatingSecretConfigOK, _a1 error) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call) RunAndReturn(run func(*secret_service.GetMongoDBAtlasRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetMongoDBAtlasRotatingSecretConfigOK, error)) *MockClientService_GetMongoDBAtlasRotatingSecretConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetRotatingSecretState provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetRotatingSecretState(params *secret_service.GetRotatingSecretStateParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetRotatingSecretStateOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2908,8 +3426,8 @@ func (_c *MockClientService_GetSyncIntegration_Call) RunAndReturn(run func(*secr return _c } -// GetTwilioRotatingSecretConfig provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetTwilioRotatingSecretConfig(params *secret_service.GetTwilioRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error) { +// GetTwilioIntegration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetTwilioIntegration(params *secret_service.GetTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetTwilioIntegrationOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2920,23 +3438,23 @@ func (_m *MockClientService) GetTwilioRotatingSecretConfig(params *secret_servic ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetTwilioRotatingSecretConfig") + panic("no return value specified for GetTwilioIntegration") } - var r0 *secret_service.GetTwilioRotatingSecretConfigOK + var r0 *secret_service.GetTwilioIntegrationOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioIntegrationOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetTwilioRotatingSecretConfigOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetTwilioIntegrationOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetTwilioRotatingSecretConfigOK) + r0 = ret.Get(0).(*secret_service.GetTwilioIntegrationOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -2945,21 +3463,21 @@ func (_m *MockClientService) GetTwilioRotatingSecretConfig(params *secret_servic return r0, r1 } -// MockClientService_GetTwilioRotatingSecretConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTwilioRotatingSecretConfig' -type MockClientService_GetTwilioRotatingSecretConfig_Call struct { +// MockClientService_GetTwilioIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTwilioIntegration' +type MockClientService_GetTwilioIntegration_Call struct { *mock.Call } -// GetTwilioRotatingSecretConfig is a helper method to define mock.On call -// - params *secret_service.GetTwilioRotatingSecretConfigParams +// GetTwilioIntegration is a helper method to define mock.On call +// - params *secret_service.GetTwilioIntegrationParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetTwilioRotatingSecretConfig(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetTwilioRotatingSecretConfig_Call { - return &MockClientService_GetTwilioRotatingSecretConfig_Call{Call: _e.mock.On("GetTwilioRotatingSecretConfig", +func (_e *MockClientService_Expecter) GetTwilioIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetTwilioIntegration_Call { + return &MockClientService_GetTwilioIntegration_Call{Call: _e.mock.On("GetTwilioIntegration", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) Run(run func(params *secret_service.GetTwilioRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetTwilioRotatingSecretConfig_Call { +func (_c *MockClientService_GetTwilioIntegration_Call) Run(run func(params *secret_service.GetTwilioIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetTwilioIntegration_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -2967,23 +3485,23 @@ func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) Run(run func(par variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetTwilioRotatingSecretConfigParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetTwilioIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) Return(_a0 *secret_service.GetTwilioRotatingSecretConfigOK, _a1 error) *MockClientService_GetTwilioRotatingSecretConfig_Call { +func (_c *MockClientService_GetTwilioIntegration_Call) Return(_a0 *secret_service.GetTwilioIntegrationOK, _a1 error) *MockClientService_GetTwilioIntegration_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) RunAndReturn(run func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error)) *MockClientService_GetTwilioRotatingSecretConfig_Call { +func (_c *MockClientService_GetTwilioIntegration_Call) RunAndReturn(run func(*secret_service.GetTwilioIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioIntegrationOK, error)) *MockClientService_GetTwilioIntegration_Call { _c.Call.Return(run) return _c } -// GetTwilioRotationIntegration provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) GetTwilioRotationIntegration(params *secret_service.GetTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetTwilioRotationIntegrationOK, error) { +// GetTwilioRotatingSecretConfig provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GetTwilioRotatingSecretConfig(params *secret_service.GetTwilioRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -2994,23 +3512,23 @@ func (_m *MockClientService) GetTwilioRotationIntegration(params *secret_service ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetTwilioRotationIntegration") + panic("no return value specified for GetTwilioRotatingSecretConfig") } - var r0 *secret_service.GetTwilioRotationIntegrationOK + var r0 *secret_service.GetTwilioRotatingSecretConfigOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotationIntegrationOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetTwilioRotationIntegrationOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.GetTwilioRotatingSecretConfigOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.GetTwilioRotationIntegrationOK) + r0 = ret.Get(0).(*secret_service.GetTwilioRotatingSecretConfigOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.GetTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -3019,21 +3537,21 @@ func (_m *MockClientService) GetTwilioRotationIntegration(params *secret_service return r0, r1 } -// MockClientService_GetTwilioRotationIntegration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTwilioRotationIntegration' -type MockClientService_GetTwilioRotationIntegration_Call struct { +// MockClientService_GetTwilioRotatingSecretConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTwilioRotatingSecretConfig' +type MockClientService_GetTwilioRotatingSecretConfig_Call struct { *mock.Call } -// GetTwilioRotationIntegration is a helper method to define mock.On call -// - params *secret_service.GetTwilioRotationIntegrationParams +// GetTwilioRotatingSecretConfig is a helper method to define mock.On call +// - params *secret_service.GetTwilioRotatingSecretConfigParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) GetTwilioRotationIntegration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetTwilioRotationIntegration_Call { - return &MockClientService_GetTwilioRotationIntegration_Call{Call: _e.mock.On("GetTwilioRotationIntegration", +func (_e *MockClientService_Expecter) GetTwilioRotatingSecretConfig(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GetTwilioRotatingSecretConfig_Call { + return &MockClientService_GetTwilioRotatingSecretConfig_Call{Call: _e.mock.On("GetTwilioRotatingSecretConfig", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_GetTwilioRotationIntegration_Call) Run(run func(params *secret_service.GetTwilioRotationIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetTwilioRotationIntegration_Call { +func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) Run(run func(params *secret_service.GetTwilioRotatingSecretConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_GetTwilioRotatingSecretConfig_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -3041,17 +3559,17 @@ func (_c *MockClientService_GetTwilioRotationIntegration_Call) Run(run func(para variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.GetTwilioRotationIntegrationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.GetTwilioRotatingSecretConfigParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_GetTwilioRotationIntegration_Call) Return(_a0 *secret_service.GetTwilioRotationIntegrationOK, _a1 error) *MockClientService_GetTwilioRotationIntegration_Call { +func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) Return(_a0 *secret_service.GetTwilioRotatingSecretConfigOK, _a1 error) *MockClientService_GetTwilioRotatingSecretConfig_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_GetTwilioRotationIntegration_Call) RunAndReturn(run func(*secret_service.GetTwilioRotationIntegrationParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotationIntegrationOK, error)) *MockClientService_GetTwilioRotationIntegration_Call { +func (_c *MockClientService_GetTwilioRotatingSecretConfig_Call) RunAndReturn(run func(*secret_service.GetTwilioRotatingSecretConfigParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.GetTwilioRotatingSecretConfigOK, error)) *MockClientService_GetTwilioRotatingSecretConfig_Call { _c.Call.Return(run) return _c } @@ -3648,6 +4166,302 @@ func (_c *MockClientService_ListAwsIntegrations_Call) RunAndReturn(run func(*sec return _c } +// ListGcpDynamicSecrets provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListGcpDynamicSecrets(params *secret_service.ListGcpDynamicSecretsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListGcpDynamicSecretsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListGcpDynamicSecrets") + } + + var r0 *secret_service.ListGcpDynamicSecretsOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ListGcpDynamicSecretsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGcpDynamicSecretsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ListGcpDynamicSecretsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListGcpDynamicSecretsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ListGcpDynamicSecretsOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ListGcpDynamicSecretsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ListGcpDynamicSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGcpDynamicSecrets' +type MockClientService_ListGcpDynamicSecrets_Call struct { + *mock.Call +} + +// ListGcpDynamicSecrets is a helper method to define mock.On call +// - params *secret_service.ListGcpDynamicSecretsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ListGcpDynamicSecrets(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListGcpDynamicSecrets_Call { + return &MockClientService_ListGcpDynamicSecrets_Call{Call: _e.mock.On("ListGcpDynamicSecrets", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ListGcpDynamicSecrets_Call) Run(run func(params *secret_service.ListGcpDynamicSecretsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListGcpDynamicSecrets_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ListGcpDynamicSecretsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ListGcpDynamicSecrets_Call) Return(_a0 *secret_service.ListGcpDynamicSecretsOK, _a1 error) *MockClientService_ListGcpDynamicSecrets_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ListGcpDynamicSecrets_Call) RunAndReturn(run func(*secret_service.ListGcpDynamicSecretsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGcpDynamicSecretsOK, error)) *MockClientService_ListGcpDynamicSecrets_Call { + _c.Call.Return(run) + return _c +} + +// ListGcpIntegrations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListGcpIntegrations(params *secret_service.ListGcpIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListGcpIntegrationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListGcpIntegrations") + } + + var r0 *secret_service.ListGcpIntegrationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ListGcpIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGcpIntegrationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ListGcpIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListGcpIntegrationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ListGcpIntegrationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ListGcpIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ListGcpIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGcpIntegrations' +type MockClientService_ListGcpIntegrations_Call struct { + *mock.Call +} + +// ListGcpIntegrations is a helper method to define mock.On call +// - params *secret_service.ListGcpIntegrationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ListGcpIntegrations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListGcpIntegrations_Call { + return &MockClientService_ListGcpIntegrations_Call{Call: _e.mock.On("ListGcpIntegrations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ListGcpIntegrations_Call) Run(run func(params *secret_service.ListGcpIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListGcpIntegrations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ListGcpIntegrationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ListGcpIntegrations_Call) Return(_a0 *secret_service.ListGcpIntegrationsOK, _a1 error) *MockClientService_ListGcpIntegrations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ListGcpIntegrations_Call) RunAndReturn(run func(*secret_service.ListGcpIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGcpIntegrationsOK, error)) *MockClientService_ListGcpIntegrations_Call { + _c.Call.Return(run) + return _c +} + +// ListGitHubInstallations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListGitHubInstallations(params *secret_service.ListGitHubInstallationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListGitHubInstallationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListGitHubInstallations") + } + + var r0 *secret_service.ListGitHubInstallationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ListGitHubInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGitHubInstallationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ListGitHubInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListGitHubInstallationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ListGitHubInstallationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ListGitHubInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ListGitHubInstallations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGitHubInstallations' +type MockClientService_ListGitHubInstallations_Call struct { + *mock.Call +} + +// ListGitHubInstallations is a helper method to define mock.On call +// - params *secret_service.ListGitHubInstallationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ListGitHubInstallations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListGitHubInstallations_Call { + return &MockClientService_ListGitHubInstallations_Call{Call: _e.mock.On("ListGitHubInstallations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ListGitHubInstallations_Call) Run(run func(params *secret_service.ListGitHubInstallationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListGitHubInstallations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ListGitHubInstallationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ListGitHubInstallations_Call) Return(_a0 *secret_service.ListGitHubInstallationsOK, _a1 error) *MockClientService_ListGitHubInstallations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ListGitHubInstallations_Call) RunAndReturn(run func(*secret_service.ListGitHubInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListGitHubInstallationsOK, error)) *MockClientService_ListGitHubInstallations_Call { + _c.Call.Return(run) + return _c +} + +// ListMongoDBAtlasIntegrations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListMongoDBAtlasIntegrations(params *secret_service.ListMongoDBAtlasIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListMongoDBAtlasIntegrationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListMongoDBAtlasIntegrations") + } + + var r0 *secret_service.ListMongoDBAtlasIntegrationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ListMongoDBAtlasIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListMongoDBAtlasIntegrationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ListMongoDBAtlasIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListMongoDBAtlasIntegrationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ListMongoDBAtlasIntegrationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ListMongoDBAtlasIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ListMongoDBAtlasIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMongoDBAtlasIntegrations' +type MockClientService_ListMongoDBAtlasIntegrations_Call struct { + *mock.Call +} + +// ListMongoDBAtlasIntegrations is a helper method to define mock.On call +// - params *secret_service.ListMongoDBAtlasIntegrationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ListMongoDBAtlasIntegrations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListMongoDBAtlasIntegrations_Call { + return &MockClientService_ListMongoDBAtlasIntegrations_Call{Call: _e.mock.On("ListMongoDBAtlasIntegrations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ListMongoDBAtlasIntegrations_Call) Run(run func(params *secret_service.ListMongoDBAtlasIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListMongoDBAtlasIntegrations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ListMongoDBAtlasIntegrationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ListMongoDBAtlasIntegrations_Call) Return(_a0 *secret_service.ListMongoDBAtlasIntegrationsOK, _a1 error) *MockClientService_ListMongoDBAtlasIntegrations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ListMongoDBAtlasIntegrations_Call) RunAndReturn(run func(*secret_service.ListMongoDBAtlasIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListMongoDBAtlasIntegrationsOK, error)) *MockClientService_ListMongoDBAtlasIntegrations_Call { + _c.Call.Return(run) + return _c +} + // ListOpenAppSecretVersions provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) ListOpenAppSecretVersions(params *secret_service.ListOpenAppSecretVersionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListOpenAppSecretVersionsOK, error) { _va := make([]interface{}, len(opts)) @@ -3722,8 +4536,8 @@ func (_c *MockClientService_ListOpenAppSecretVersions_Call) RunAndReturn(run fun return _c } -// ListRotationIntegrations provides a mock function with given fields: params, authInfo, opts -func (_m *MockClientService) ListRotationIntegrations(params *secret_service.ListRotationIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListRotationIntegrationsOK, error) { +// ListSyncInstallations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListSyncInstallations(params *secret_service.ListSyncInstallationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListSyncInstallationsOK, error) { _va := make([]interface{}, len(opts)) for _i := range opts { _va[_i] = opts[_i] @@ -3734,23 +4548,23 @@ func (_m *MockClientService) ListRotationIntegrations(params *secret_service.Lis ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for ListRotationIntegrations") + panic("no return value specified for ListSyncInstallations") } - var r0 *secret_service.ListRotationIntegrationsOK + var r0 *secret_service.ListSyncInstallationsOK var r1 error - if rf, ok := ret.Get(0).(func(*secret_service.ListRotationIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListRotationIntegrationsOK, error)); ok { + if rf, ok := ret.Get(0).(func(*secret_service.ListSyncInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListSyncInstallationsOK, error)); ok { return rf(params, authInfo, opts...) } - if rf, ok := ret.Get(0).(func(*secret_service.ListRotationIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListRotationIntegrationsOK); ok { + if rf, ok := ret.Get(0).(func(*secret_service.ListSyncInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListSyncInstallationsOK); ok { r0 = rf(params, authInfo, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*secret_service.ListRotationIntegrationsOK) + r0 = ret.Get(0).(*secret_service.ListSyncInstallationsOK) } } - if rf, ok := ret.Get(1).(func(*secret_service.ListRotationIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + if rf, ok := ret.Get(1).(func(*secret_service.ListSyncInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { r1 = rf(params, authInfo, opts...) } else { r1 = ret.Error(1) @@ -3759,21 +4573,21 @@ func (_m *MockClientService) ListRotationIntegrations(params *secret_service.Lis return r0, r1 } -// MockClientService_ListRotationIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRotationIntegrations' -type MockClientService_ListRotationIntegrations_Call struct { +// MockClientService_ListSyncInstallations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSyncInstallations' +type MockClientService_ListSyncInstallations_Call struct { *mock.Call } -// ListRotationIntegrations is a helper method to define mock.On call -// - params *secret_service.ListRotationIntegrationsParams +// ListSyncInstallations is a helper method to define mock.On call +// - params *secret_service.ListSyncInstallationsParams // - authInfo runtime.ClientAuthInfoWriter // - opts ...secret_service.ClientOption -func (_e *MockClientService_Expecter) ListRotationIntegrations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListRotationIntegrations_Call { - return &MockClientService_ListRotationIntegrations_Call{Call: _e.mock.On("ListRotationIntegrations", +func (_e *MockClientService_Expecter) ListSyncInstallations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListSyncInstallations_Call { + return &MockClientService_ListSyncInstallations_Call{Call: _e.mock.On("ListSyncInstallations", append([]interface{}{params, authInfo}, opts...)...)} } -func (_c *MockClientService_ListRotationIntegrations_Call) Run(run func(params *secret_service.ListRotationIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListRotationIntegrations_Call { +func (_c *MockClientService_ListSyncInstallations_Call) Run(run func(params *secret_service.ListSyncInstallationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListSyncInstallations_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]secret_service.ClientOption, len(args)-2) for i, a := range args[2:] { @@ -3781,17 +4595,17 @@ func (_c *MockClientService_ListRotationIntegrations_Call) Run(run func(params * variadicArgs[i] = a.(secret_service.ClientOption) } } - run(args[0].(*secret_service.ListRotationIntegrationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + run(args[0].(*secret_service.ListSyncInstallationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) }) return _c } -func (_c *MockClientService_ListRotationIntegrations_Call) Return(_a0 *secret_service.ListRotationIntegrationsOK, _a1 error) *MockClientService_ListRotationIntegrations_Call { +func (_c *MockClientService_ListSyncInstallations_Call) Return(_a0 *secret_service.ListSyncInstallationsOK, _a1 error) *MockClientService_ListSyncInstallations_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *MockClientService_ListRotationIntegrations_Call) RunAndReturn(run func(*secret_service.ListRotationIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListRotationIntegrationsOK, error)) *MockClientService_ListRotationIntegrations_Call { +func (_c *MockClientService_ListSyncInstallations_Call) RunAndReturn(run func(*secret_service.ListSyncInstallationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListSyncInstallationsOK, error)) *MockClientService_ListSyncInstallations_Call { _c.Call.Return(run) return _c } @@ -3870,6 +4684,80 @@ func (_c *MockClientService_ListSyncIntegrations_Call) RunAndReturn(run func(*se return _c } +// ListTwilioIntegrations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ListTwilioIntegrations(params *secret_service.ListTwilioIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.ListTwilioIntegrationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListTwilioIntegrations") + } + + var r0 *secret_service.ListTwilioIntegrationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*secret_service.ListTwilioIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListTwilioIntegrationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*secret_service.ListTwilioIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) *secret_service.ListTwilioIntegrationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*secret_service.ListTwilioIntegrationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*secret_service.ListTwilioIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ListTwilioIntegrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTwilioIntegrations' +type MockClientService_ListTwilioIntegrations_Call struct { + *mock.Call +} + +// ListTwilioIntegrations is a helper method to define mock.On call +// - params *secret_service.ListTwilioIntegrationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...secret_service.ClientOption +func (_e *MockClientService_Expecter) ListTwilioIntegrations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ListTwilioIntegrations_Call { + return &MockClientService_ListTwilioIntegrations_Call{Call: _e.mock.On("ListTwilioIntegrations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ListTwilioIntegrations_Call) Run(run func(params *secret_service.ListTwilioIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption)) *MockClientService_ListTwilioIntegrations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]secret_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(secret_service.ClientOption) + } + } + run(args[0].(*secret_service.ListTwilioIntegrationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ListTwilioIntegrations_Call) Return(_a0 *secret_service.ListTwilioIntegrationsOK, _a1 error) *MockClientService_ListTwilioIntegrations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ListTwilioIntegrations_Call) RunAndReturn(run func(*secret_service.ListTwilioIntegrationsParams, runtime.ClientAuthInfoWriter, ...secret_service.ClientOption) (*secret_service.ListTwilioIntegrationsOK, error)) *MockClientService_ListTwilioIntegrations_Call { + _c.Call.Return(run) + return _c +} + // OpenAppSecret provides a mock function with given fields: params, authInfo, opts func (_m *MockClientService) OpenAppSecret(params *secret_service.OpenAppSecretParams, authInfo runtime.ClientAuthInfoWriter, opts ...secret_service.ClientOption) (*secret_service.OpenAppSecretOK, error) { _va := make([]interface{}, len(opts)) diff --git a/internal/pkg/api/releasesapi/mocks/mock_ClientOption.go b/internal/pkg/api/releasesapi/mocks/mock_ClientOption.go deleted file mode 100644 index bf890c0f..00000000 --- a/internal/pkg/api/releasesapi/mocks/mock_ClientOption.go +++ /dev/null @@ -1,69 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mock_operations - -import ( - mock "github.com/stretchr/testify/mock" - - runtime "github.com/go-openapi/runtime" -) - -// MockClientOption is an autogenerated mock type for the ClientOption type -type MockClientOption struct { - mock.Mock -} - -type MockClientOption_Expecter struct { - mock *mock.Mock -} - -func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { - return &MockClientOption_Expecter{mock: &_m.Mock} -} - -// Execute provides a mock function with given fields: _a0 -func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { - _m.Called(_a0) -} - -// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' -type MockClientOption_Execute_Call struct { - *mock.Call -} - -// Execute is a helper method to define mock.On call -// - _a0 *runtime.ClientOperation -func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { - return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} -} - -func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*runtime.ClientOperation)) - }) - return _c -} - -func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { - _c.Call.Return() - return _c -} - -func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { - _c.Call.Return(run) - return _c -} - -// NewMockClientOption creates a new instance of MockClientOption. 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 NewMockClientOption(t interface { - mock.TestingT - Cleanup(func()) -}) *MockClientOption { - mock := &MockClientOption{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/internal/pkg/api/releasesapi/mocks/mock_ClientService.go b/internal/pkg/api/releasesapi/mocks/mock_ClientService.go deleted file mode 100644 index 87e39e34..00000000 --- a/internal/pkg/api/releasesapi/mocks/mock_ClientService.go +++ /dev/null @@ -1,288 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mock_operations - -import ( - runtime "github.com/go-openapi/runtime" - operations "github.com/hashicorp/hcp/internal/pkg/api/releasesapi/client/operations" - mock "github.com/stretchr/testify/mock" -) - -// MockClientService is an autogenerated mock type for the ClientService type -type MockClientService struct { - mock.Mock -} - -type MockClientService_Expecter struct { - mock *mock.Mock -} - -func (_m *MockClientService) EXPECT() *MockClientService_Expecter { - return &MockClientService_Expecter{mock: &_m.Mock} -} - -// GetReleaseV1 provides a mock function with given fields: params, opts -func (_m *MockClientService) GetReleaseV1(params *operations.GetReleaseV1Params, opts ...operations.ClientOption) (*operations.GetReleaseV1OK, error) { - _va := make([]interface{}, len(opts)) - for _i := range opts { - _va[_i] = opts[_i] - } - var _ca []interface{} - _ca = append(_ca, params) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for GetReleaseV1") - } - - var r0 *operations.GetReleaseV1OK - var r1 error - if rf, ok := ret.Get(0).(func(*operations.GetReleaseV1Params, ...operations.ClientOption) (*operations.GetReleaseV1OK, error)); ok { - return rf(params, opts...) - } - if rf, ok := ret.Get(0).(func(*operations.GetReleaseV1Params, ...operations.ClientOption) *operations.GetReleaseV1OK); ok { - r0 = rf(params, opts...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*operations.GetReleaseV1OK) - } - } - - if rf, ok := ret.Get(1).(func(*operations.GetReleaseV1Params, ...operations.ClientOption) error); ok { - r1 = rf(params, opts...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockClientService_GetReleaseV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReleaseV1' -type MockClientService_GetReleaseV1_Call struct { - *mock.Call -} - -// GetReleaseV1 is a helper method to define mock.On call -// - params *operations.GetReleaseV1Params -// - opts ...operations.ClientOption -func (_e *MockClientService_Expecter) GetReleaseV1(params interface{}, opts ...interface{}) *MockClientService_GetReleaseV1_Call { - return &MockClientService_GetReleaseV1_Call{Call: _e.mock.On("GetReleaseV1", - append([]interface{}{params}, opts...)...)} -} - -func (_c *MockClientService_GetReleaseV1_Call) Run(run func(params *operations.GetReleaseV1Params, opts ...operations.ClientOption)) *MockClientService_GetReleaseV1_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]operations.ClientOption, len(args)-1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(operations.ClientOption) - } - } - run(args[0].(*operations.GetReleaseV1Params), variadicArgs...) - }) - return _c -} - -func (_c *MockClientService_GetReleaseV1_Call) Return(_a0 *operations.GetReleaseV1OK, _a1 error) *MockClientService_GetReleaseV1_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockClientService_GetReleaseV1_Call) RunAndReturn(run func(*operations.GetReleaseV1Params, ...operations.ClientOption) (*operations.GetReleaseV1OK, error)) *MockClientService_GetReleaseV1_Call { - _c.Call.Return(run) - return _c -} - -// ListProductsV1 provides a mock function with given fields: params, opts -func (_m *MockClientService) ListProductsV1(params *operations.ListProductsV1Params, opts ...operations.ClientOption) (*operations.ListProductsV1OK, error) { - _va := make([]interface{}, len(opts)) - for _i := range opts { - _va[_i] = opts[_i] - } - var _ca []interface{} - _ca = append(_ca, params) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for ListProductsV1") - } - - var r0 *operations.ListProductsV1OK - var r1 error - if rf, ok := ret.Get(0).(func(*operations.ListProductsV1Params, ...operations.ClientOption) (*operations.ListProductsV1OK, error)); ok { - return rf(params, opts...) - } - if rf, ok := ret.Get(0).(func(*operations.ListProductsV1Params, ...operations.ClientOption) *operations.ListProductsV1OK); ok { - r0 = rf(params, opts...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*operations.ListProductsV1OK) - } - } - - if rf, ok := ret.Get(1).(func(*operations.ListProductsV1Params, ...operations.ClientOption) error); ok { - r1 = rf(params, opts...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockClientService_ListProductsV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProductsV1' -type MockClientService_ListProductsV1_Call struct { - *mock.Call -} - -// ListProductsV1 is a helper method to define mock.On call -// - params *operations.ListProductsV1Params -// - opts ...operations.ClientOption -func (_e *MockClientService_Expecter) ListProductsV1(params interface{}, opts ...interface{}) *MockClientService_ListProductsV1_Call { - return &MockClientService_ListProductsV1_Call{Call: _e.mock.On("ListProductsV1", - append([]interface{}{params}, opts...)...)} -} - -func (_c *MockClientService_ListProductsV1_Call) Run(run func(params *operations.ListProductsV1Params, opts ...operations.ClientOption)) *MockClientService_ListProductsV1_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]operations.ClientOption, len(args)-1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(operations.ClientOption) - } - } - run(args[0].(*operations.ListProductsV1Params), variadicArgs...) - }) - return _c -} - -func (_c *MockClientService_ListProductsV1_Call) Return(_a0 *operations.ListProductsV1OK, _a1 error) *MockClientService_ListProductsV1_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockClientService_ListProductsV1_Call) RunAndReturn(run func(*operations.ListProductsV1Params, ...operations.ClientOption) (*operations.ListProductsV1OK, error)) *MockClientService_ListProductsV1_Call { - _c.Call.Return(run) - return _c -} - -// ListReleasesV1 provides a mock function with given fields: params, opts -func (_m *MockClientService) ListReleasesV1(params *operations.ListReleasesV1Params, opts ...operations.ClientOption) (*operations.ListReleasesV1OK, error) { - _va := make([]interface{}, len(opts)) - for _i := range opts { - _va[_i] = opts[_i] - } - var _ca []interface{} - _ca = append(_ca, params) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for ListReleasesV1") - } - - var r0 *operations.ListReleasesV1OK - var r1 error - if rf, ok := ret.Get(0).(func(*operations.ListReleasesV1Params, ...operations.ClientOption) (*operations.ListReleasesV1OK, error)); ok { - return rf(params, opts...) - } - if rf, ok := ret.Get(0).(func(*operations.ListReleasesV1Params, ...operations.ClientOption) *operations.ListReleasesV1OK); ok { - r0 = rf(params, opts...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*operations.ListReleasesV1OK) - } - } - - if rf, ok := ret.Get(1).(func(*operations.ListReleasesV1Params, ...operations.ClientOption) error); ok { - r1 = rf(params, opts...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockClientService_ListReleasesV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReleasesV1' -type MockClientService_ListReleasesV1_Call struct { - *mock.Call -} - -// ListReleasesV1 is a helper method to define mock.On call -// - params *operations.ListReleasesV1Params -// - opts ...operations.ClientOption -func (_e *MockClientService_Expecter) ListReleasesV1(params interface{}, opts ...interface{}) *MockClientService_ListReleasesV1_Call { - return &MockClientService_ListReleasesV1_Call{Call: _e.mock.On("ListReleasesV1", - append([]interface{}{params}, opts...)...)} -} - -func (_c *MockClientService_ListReleasesV1_Call) Run(run func(params *operations.ListReleasesV1Params, opts ...operations.ClientOption)) *MockClientService_ListReleasesV1_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]operations.ClientOption, len(args)-1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(operations.ClientOption) - } - } - run(args[0].(*operations.ListReleasesV1Params), variadicArgs...) - }) - return _c -} - -func (_c *MockClientService_ListReleasesV1_Call) Return(_a0 *operations.ListReleasesV1OK, _a1 error) *MockClientService_ListReleasesV1_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockClientService_ListReleasesV1_Call) RunAndReturn(run func(*operations.ListReleasesV1Params, ...operations.ClientOption) (*operations.ListReleasesV1OK, error)) *MockClientService_ListReleasesV1_Call { - _c.Call.Return(run) - return _c -} - -// SetTransport provides a mock function with given fields: transport -func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { - _m.Called(transport) -} - -// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' -type MockClientService_SetTransport_Call struct { - *mock.Call -} - -// SetTransport is a helper method to define mock.On call -// - transport runtime.ClientTransport -func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { - return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} -} - -func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(runtime.ClientTransport)) - }) - return _c -} - -func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { - _c.Call.Return() - return _c -} - -func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { - _c.Call.Return(run) - return _c -} - -// NewMockClientService creates a new instance of MockClientService. 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 NewMockClientService(t interface { - mock.TestingT - Cleanup(func()) -}) *MockClientService { - mock := &MockClientService{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/mongo-secret.yaml b/mongo-secret.yaml new file mode 100644 index 00000000..c4f08830 --- /dev/null +++ b/mongo-secret.yaml @@ -0,0 +1,10 @@ +version: "2024-06-24" +secret_name: "clisecretmongo" +rotation_integration_type: "mongodb" +rotation_integration_name: "climongo" +rotation_pol_name: "built-in:30-days-2-active" +details: + group_id: "{mongo_project_id}" + roles: + - role_name: "readWrite" + database_name: "newclust" \ No newline at end of file