From 9d84b65a2a05299911c6c9fda6d8bc3b9112f343 Mon Sep 17 00:00:00 2001 From: Repository CI Date: Tue, 31 Oct 2023 02:25:34 +0000 Subject: [PATCH] Automatic ci update Version into v1.46.7 --- aws-sdk.version | 2 +- go.mod | 2 +- go.sum | 2 + service/dataexchangemock/mock.go | 50 +++++ service/finspacemock/mock.go | 50 +++++ service/rdsmock/mock.go | 183 ++++++++++++++++ service/redshiftserverlessmock/mock.go | 283 +++++++++++++++++++++++++ 7 files changed, 570 insertions(+), 2 deletions(-) diff --git a/aws-sdk.version b/aws-sdk.version index ea83ba04..2f58ae1e 100755 --- a/aws-sdk.version +++ b/aws-sdk.version @@ -1 +1 @@ -v1.46.6 +v1.46.7 diff --git a/go.mod b/go.mod index 9bc41266..328e9e17 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/Itarix/aws-sdk-go-mocks go 1.15 require ( - github.com/aws/aws-sdk-go v1.46.6 + github.com/aws/aws-sdk-go v1.46.7 github.com/davecgh/go-spew v1.1.1 // indirect github.com/golang/mock v1.4.4 github.com/pmezard/go-difflib v1.0.0 // indirect diff --git a/go.sum b/go.sum index c84a2410..fe314aab 100644 --- a/go.sum +++ b/go.sum @@ -2294,6 +2294,8 @@ github.com/aws/aws-sdk-go v1.46.5 h1:NYYUrhOftwiXPkqZwEpB3043bMukegJAt15ozrqJbEY github.com/aws/aws-sdk-go v1.46.5/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go v1.46.6 h1:6wFnNC9hETIZLMf6SOTN7IcclrOGwp/n9SLp8Pjt6E8= github.com/aws/aws-sdk-go v1.46.6/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= +github.com/aws/aws-sdk-go v1.46.7 h1:IjvAWeiJZlbETOemOwvheN5L17CvKvKW0T1xOC6d3Sc= +github.com/aws/aws-sdk-go v1.46.7/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= diff --git a/service/dataexchangemock/mock.go b/service/dataexchangemock/mock.go index 7a244e12..9a284731 100644 --- a/service/dataexchangemock/mock.go +++ b/service/dataexchangemock/mock.go @@ -1300,6 +1300,56 @@ func (mr *MockDataExchangeAPIMockRecorder) SendApiAssetWithContext(arg0, arg1 in return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendApiAssetWithContext", reflect.TypeOf((*MockDataExchangeAPI)(nil).SendApiAssetWithContext), varargs...) } +// SendDataSetNotification mocks base method +func (m *MockDataExchangeAPI) SendDataSetNotification(arg0 *dataexchange.SendDataSetNotificationInput) (*dataexchange.SendDataSetNotificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDataSetNotification", arg0) + ret0, _ := ret[0].(*dataexchange.SendDataSetNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDataSetNotification indicates an expected call of SendDataSetNotification +func (mr *MockDataExchangeAPIMockRecorder) SendDataSetNotification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDataSetNotification", reflect.TypeOf((*MockDataExchangeAPI)(nil).SendDataSetNotification), arg0) +} + +// SendDataSetNotificationRequest mocks base method +func (m *MockDataExchangeAPI) SendDataSetNotificationRequest(arg0 *dataexchange.SendDataSetNotificationInput) (*request.Request, *dataexchange.SendDataSetNotificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDataSetNotificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*dataexchange.SendDataSetNotificationOutput) + return ret0, ret1 +} + +// SendDataSetNotificationRequest indicates an expected call of SendDataSetNotificationRequest +func (mr *MockDataExchangeAPIMockRecorder) SendDataSetNotificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDataSetNotificationRequest", reflect.TypeOf((*MockDataExchangeAPI)(nil).SendDataSetNotificationRequest), arg0) +} + +// SendDataSetNotificationWithContext mocks base method +func (m *MockDataExchangeAPI) SendDataSetNotificationWithContext(arg0 context.Context, arg1 *dataexchange.SendDataSetNotificationInput, arg2 ...request.Option) (*dataexchange.SendDataSetNotificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendDataSetNotificationWithContext", varargs...) + ret0, _ := ret[0].(*dataexchange.SendDataSetNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDataSetNotificationWithContext indicates an expected call of SendDataSetNotificationWithContext +func (mr *MockDataExchangeAPIMockRecorder) SendDataSetNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDataSetNotificationWithContext", reflect.TypeOf((*MockDataExchangeAPI)(nil).SendDataSetNotificationWithContext), varargs...) +} + // StartJob mocks base method func (m *MockDataExchangeAPI) StartJob(arg0 *dataexchange.StartJobInput) (*dataexchange.StartJobOutput, error) { m.ctrl.T.Helper() diff --git a/service/finspacemock/mock.go b/service/finspacemock/mock.go index 41444d8e..70b0e8ff 100644 --- a/service/finspacemock/mock.go +++ b/service/finspacemock/mock.go @@ -1617,6 +1617,56 @@ func (mr *MockFinspaceAPIMockRecorder) UpdateEnvironmentWithContext(arg0, arg1 i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEnvironmentWithContext", reflect.TypeOf((*MockFinspaceAPI)(nil).UpdateEnvironmentWithContext), varargs...) } +// UpdateKxClusterCodeConfiguration mocks base method +func (m *MockFinspaceAPI) UpdateKxClusterCodeConfiguration(arg0 *finspace.UpdateKxClusterCodeConfigurationInput) (*finspace.UpdateKxClusterCodeConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateKxClusterCodeConfiguration", arg0) + ret0, _ := ret[0].(*finspace.UpdateKxClusterCodeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateKxClusterCodeConfiguration indicates an expected call of UpdateKxClusterCodeConfiguration +func (mr *MockFinspaceAPIMockRecorder) UpdateKxClusterCodeConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKxClusterCodeConfiguration", reflect.TypeOf((*MockFinspaceAPI)(nil).UpdateKxClusterCodeConfiguration), arg0) +} + +// UpdateKxClusterCodeConfigurationRequest mocks base method +func (m *MockFinspaceAPI) UpdateKxClusterCodeConfigurationRequest(arg0 *finspace.UpdateKxClusterCodeConfigurationInput) (*request.Request, *finspace.UpdateKxClusterCodeConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateKxClusterCodeConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*finspace.UpdateKxClusterCodeConfigurationOutput) + return ret0, ret1 +} + +// UpdateKxClusterCodeConfigurationRequest indicates an expected call of UpdateKxClusterCodeConfigurationRequest +func (mr *MockFinspaceAPIMockRecorder) UpdateKxClusterCodeConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKxClusterCodeConfigurationRequest", reflect.TypeOf((*MockFinspaceAPI)(nil).UpdateKxClusterCodeConfigurationRequest), arg0) +} + +// UpdateKxClusterCodeConfigurationWithContext mocks base method +func (m *MockFinspaceAPI) UpdateKxClusterCodeConfigurationWithContext(arg0 context.Context, arg1 *finspace.UpdateKxClusterCodeConfigurationInput, arg2 ...request.Option) (*finspace.UpdateKxClusterCodeConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateKxClusterCodeConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*finspace.UpdateKxClusterCodeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateKxClusterCodeConfigurationWithContext indicates an expected call of UpdateKxClusterCodeConfigurationWithContext +func (mr *MockFinspaceAPIMockRecorder) UpdateKxClusterCodeConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKxClusterCodeConfigurationWithContext", reflect.TypeOf((*MockFinspaceAPI)(nil).UpdateKxClusterCodeConfigurationWithContext), varargs...) +} + // UpdateKxClusterDatabases mocks base method func (m *MockFinspaceAPI) UpdateKxClusterDatabases(arg0 *finspace.UpdateKxClusterDatabasesInput) (*finspace.UpdateKxClusterDatabasesOutput, error) { m.ctrl.T.Helper() diff --git a/service/rdsmock/mock.go b/service/rdsmock/mock.go index c2f3797c..fa353bec 100644 --- a/service/rdsmock/mock.go +++ b/service/rdsmock/mock.go @@ -1485,6 +1485,56 @@ func (mr *MockRDSAPIMockRecorder) CreateGlobalClusterWithContext(arg0, arg1 inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateGlobalClusterWithContext), varargs...) } +// CreateIntegration mocks base method +func (m *MockRDSAPI) CreateIntegration(arg0 *rds.CreateIntegrationInput) (*rds.CreateIntegrationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateIntegration", arg0) + ret0, _ := ret[0].(*rds.CreateIntegrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateIntegration indicates an expected call of CreateIntegration +func (mr *MockRDSAPIMockRecorder) CreateIntegration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIntegration", reflect.TypeOf((*MockRDSAPI)(nil).CreateIntegration), arg0) +} + +// CreateIntegrationRequest mocks base method +func (m *MockRDSAPI) CreateIntegrationRequest(arg0 *rds.CreateIntegrationInput) (*request.Request, *rds.CreateIntegrationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateIntegrationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*rds.CreateIntegrationOutput) + return ret0, ret1 +} + +// CreateIntegrationRequest indicates an expected call of CreateIntegrationRequest +func (mr *MockRDSAPIMockRecorder) CreateIntegrationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIntegrationRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateIntegrationRequest), arg0) +} + +// CreateIntegrationWithContext mocks base method +func (m *MockRDSAPI) CreateIntegrationWithContext(arg0 context.Context, arg1 *rds.CreateIntegrationInput, arg2 ...request.Option) (*rds.CreateIntegrationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateIntegrationWithContext", varargs...) + ret0, _ := ret[0].(*rds.CreateIntegrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateIntegrationWithContext indicates an expected call of CreateIntegrationWithContext +func (mr *MockRDSAPIMockRecorder) CreateIntegrationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIntegrationWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateIntegrationWithContext), varargs...) +} + // CreateOptionGroup mocks base method func (m *MockRDSAPI) CreateOptionGroup(arg0 *rds.CreateOptionGroupInput) (*rds.CreateOptionGroupOutput, error) { m.ctrl.T.Helper() @@ -2385,6 +2435,56 @@ func (mr *MockRDSAPIMockRecorder) DeleteGlobalClusterWithContext(arg0, arg1 inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalClusterWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteGlobalClusterWithContext), varargs...) } +// DeleteIntegration mocks base method +func (m *MockRDSAPI) DeleteIntegration(arg0 *rds.DeleteIntegrationInput) (*rds.DeleteIntegrationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteIntegration", arg0) + ret0, _ := ret[0].(*rds.DeleteIntegrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteIntegration indicates an expected call of DeleteIntegration +func (mr *MockRDSAPIMockRecorder) DeleteIntegration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIntegration", reflect.TypeOf((*MockRDSAPI)(nil).DeleteIntegration), arg0) +} + +// DeleteIntegrationRequest mocks base method +func (m *MockRDSAPI) DeleteIntegrationRequest(arg0 *rds.DeleteIntegrationInput) (*request.Request, *rds.DeleteIntegrationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteIntegrationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*rds.DeleteIntegrationOutput) + return ret0, ret1 +} + +// DeleteIntegrationRequest indicates an expected call of DeleteIntegrationRequest +func (mr *MockRDSAPIMockRecorder) DeleteIntegrationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIntegrationRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteIntegrationRequest), arg0) +} + +// DeleteIntegrationWithContext mocks base method +func (m *MockRDSAPI) DeleteIntegrationWithContext(arg0 context.Context, arg1 *rds.DeleteIntegrationInput, arg2 ...request.Option) (*rds.DeleteIntegrationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteIntegrationWithContext", varargs...) + ret0, _ := ret[0].(*rds.DeleteIntegrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteIntegrationWithContext indicates an expected call of DeleteIntegrationWithContext +func (mr *MockRDSAPIMockRecorder) DeleteIntegrationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIntegrationWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteIntegrationWithContext), varargs...) +} + // DeleteOptionGroup mocks base method func (m *MockRDSAPI) DeleteOptionGroup(arg0 *rds.DeleteOptionGroupInput) (*rds.DeleteOptionGroupOutput, error) { m.ctrl.T.Helper() @@ -4976,6 +5076,89 @@ func (mr *MockRDSAPIMockRecorder) DescribeGlobalClustersWithContext(arg0, arg1 i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalClustersWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeGlobalClustersWithContext), varargs...) } +// DescribeIntegrations mocks base method +func (m *MockRDSAPI) DescribeIntegrations(arg0 *rds.DescribeIntegrationsInput) (*rds.DescribeIntegrationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIntegrations", arg0) + ret0, _ := ret[0].(*rds.DescribeIntegrationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIntegrations indicates an expected call of DescribeIntegrations +func (mr *MockRDSAPIMockRecorder) DescribeIntegrations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIntegrations", reflect.TypeOf((*MockRDSAPI)(nil).DescribeIntegrations), arg0) +} + +// DescribeIntegrationsPages mocks base method +func (m *MockRDSAPI) DescribeIntegrationsPages(arg0 *rds.DescribeIntegrationsInput, arg1 func(*rds.DescribeIntegrationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIntegrationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIntegrationsPages indicates an expected call of DescribeIntegrationsPages +func (mr *MockRDSAPIMockRecorder) DescribeIntegrationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIntegrationsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeIntegrationsPages), arg0, arg1) +} + +// DescribeIntegrationsPagesWithContext mocks base method +func (m *MockRDSAPI) DescribeIntegrationsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeIntegrationsInput, arg2 func(*rds.DescribeIntegrationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIntegrationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIntegrationsPagesWithContext indicates an expected call of DescribeIntegrationsPagesWithContext +func (mr *MockRDSAPIMockRecorder) DescribeIntegrationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIntegrationsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeIntegrationsPagesWithContext), varargs...) +} + +// DescribeIntegrationsRequest mocks base method +func (m *MockRDSAPI) DescribeIntegrationsRequest(arg0 *rds.DescribeIntegrationsInput) (*request.Request, *rds.DescribeIntegrationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIntegrationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*rds.DescribeIntegrationsOutput) + return ret0, ret1 +} + +// DescribeIntegrationsRequest indicates an expected call of DescribeIntegrationsRequest +func (mr *MockRDSAPIMockRecorder) DescribeIntegrationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIntegrationsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeIntegrationsRequest), arg0) +} + +// DescribeIntegrationsWithContext mocks base method +func (m *MockRDSAPI) DescribeIntegrationsWithContext(arg0 context.Context, arg1 *rds.DescribeIntegrationsInput, arg2 ...request.Option) (*rds.DescribeIntegrationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIntegrationsWithContext", varargs...) + ret0, _ := ret[0].(*rds.DescribeIntegrationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIntegrationsWithContext indicates an expected call of DescribeIntegrationsWithContext +func (mr *MockRDSAPIMockRecorder) DescribeIntegrationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIntegrationsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeIntegrationsWithContext), varargs...) +} + // DescribeOptionGroupOptions mocks base method func (m *MockRDSAPI) DescribeOptionGroupOptions(arg0 *rds.DescribeOptionGroupOptionsInput) (*rds.DescribeOptionGroupOptionsOutput, error) { m.ctrl.T.Helper() diff --git a/service/redshiftserverlessmock/mock.go b/service/redshiftserverlessmock/mock.go index ad59cc2d..93beef3c 100644 --- a/service/redshiftserverlessmock/mock.go +++ b/service/redshiftserverlessmock/mock.go @@ -85,6 +85,56 @@ func (mr *MockRedshiftServerlessAPIMockRecorder) ConvertRecoveryPointToSnapshotW return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertRecoveryPointToSnapshotWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ConvertRecoveryPointToSnapshotWithContext), varargs...) } +// CreateCustomDomainAssociation mocks base method +func (m *MockRedshiftServerlessAPI) CreateCustomDomainAssociation(arg0 *redshiftserverless.CreateCustomDomainAssociationInput) (*redshiftserverless.CreateCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomDomainAssociation", arg0) + ret0, _ := ret[0].(*redshiftserverless.CreateCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomDomainAssociation indicates an expected call of CreateCustomDomainAssociation +func (mr *MockRedshiftServerlessAPIMockRecorder) CreateCustomDomainAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomDomainAssociation", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).CreateCustomDomainAssociation), arg0) +} + +// CreateCustomDomainAssociationRequest mocks base method +func (m *MockRedshiftServerlessAPI) CreateCustomDomainAssociationRequest(arg0 *redshiftserverless.CreateCustomDomainAssociationInput) (*request.Request, *redshiftserverless.CreateCustomDomainAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomDomainAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*redshiftserverless.CreateCustomDomainAssociationOutput) + return ret0, ret1 +} + +// CreateCustomDomainAssociationRequest indicates an expected call of CreateCustomDomainAssociationRequest +func (mr *MockRedshiftServerlessAPIMockRecorder) CreateCustomDomainAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomDomainAssociationRequest", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).CreateCustomDomainAssociationRequest), arg0) +} + +// CreateCustomDomainAssociationWithContext mocks base method +func (m *MockRedshiftServerlessAPI) CreateCustomDomainAssociationWithContext(arg0 context.Context, arg1 *redshiftserverless.CreateCustomDomainAssociationInput, arg2 ...request.Option) (*redshiftserverless.CreateCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCustomDomainAssociationWithContext", varargs...) + ret0, _ := ret[0].(*redshiftserverless.CreateCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomDomainAssociationWithContext indicates an expected call of CreateCustomDomainAssociationWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) CreateCustomDomainAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomDomainAssociationWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).CreateCustomDomainAssociationWithContext), varargs...) +} + // CreateEndpointAccess mocks base method func (m *MockRedshiftServerlessAPI) CreateEndpointAccess(arg0 *redshiftserverless.CreateEndpointAccessInput) (*redshiftserverless.CreateEndpointAccessOutput, error) { m.ctrl.T.Helper() @@ -335,6 +385,56 @@ func (mr *MockRedshiftServerlessAPIMockRecorder) CreateWorkgroupWithContext(arg0 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkgroupWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).CreateWorkgroupWithContext), varargs...) } +// DeleteCustomDomainAssociation mocks base method +func (m *MockRedshiftServerlessAPI) DeleteCustomDomainAssociation(arg0 *redshiftserverless.DeleteCustomDomainAssociationInput) (*redshiftserverless.DeleteCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomDomainAssociation", arg0) + ret0, _ := ret[0].(*redshiftserverless.DeleteCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomDomainAssociation indicates an expected call of DeleteCustomDomainAssociation +func (mr *MockRedshiftServerlessAPIMockRecorder) DeleteCustomDomainAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomDomainAssociation", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).DeleteCustomDomainAssociation), arg0) +} + +// DeleteCustomDomainAssociationRequest mocks base method +func (m *MockRedshiftServerlessAPI) DeleteCustomDomainAssociationRequest(arg0 *redshiftserverless.DeleteCustomDomainAssociationInput) (*request.Request, *redshiftserverless.DeleteCustomDomainAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomDomainAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*redshiftserverless.DeleteCustomDomainAssociationOutput) + return ret0, ret1 +} + +// DeleteCustomDomainAssociationRequest indicates an expected call of DeleteCustomDomainAssociationRequest +func (mr *MockRedshiftServerlessAPIMockRecorder) DeleteCustomDomainAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomDomainAssociationRequest", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).DeleteCustomDomainAssociationRequest), arg0) +} + +// DeleteCustomDomainAssociationWithContext mocks base method +func (m *MockRedshiftServerlessAPI) DeleteCustomDomainAssociationWithContext(arg0 context.Context, arg1 *redshiftserverless.DeleteCustomDomainAssociationInput, arg2 ...request.Option) (*redshiftserverless.DeleteCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteCustomDomainAssociationWithContext", varargs...) + ret0, _ := ret[0].(*redshiftserverless.DeleteCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomDomainAssociationWithContext indicates an expected call of DeleteCustomDomainAssociationWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) DeleteCustomDomainAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomDomainAssociationWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).DeleteCustomDomainAssociationWithContext), varargs...) +} + // DeleteEndpointAccess mocks base method func (m *MockRedshiftServerlessAPI) DeleteEndpointAccess(arg0 *redshiftserverless.DeleteEndpointAccessInput) (*redshiftserverless.DeleteEndpointAccessOutput, error) { m.ctrl.T.Helper() @@ -685,6 +785,56 @@ func (mr *MockRedshiftServerlessAPIMockRecorder) GetCredentialsWithContext(arg0, return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredentialsWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).GetCredentialsWithContext), varargs...) } +// GetCustomDomainAssociation mocks base method +func (m *MockRedshiftServerlessAPI) GetCustomDomainAssociation(arg0 *redshiftserverless.GetCustomDomainAssociationInput) (*redshiftserverless.GetCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCustomDomainAssociation", arg0) + ret0, _ := ret[0].(*redshiftserverless.GetCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCustomDomainAssociation indicates an expected call of GetCustomDomainAssociation +func (mr *MockRedshiftServerlessAPIMockRecorder) GetCustomDomainAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomDomainAssociation", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).GetCustomDomainAssociation), arg0) +} + +// GetCustomDomainAssociationRequest mocks base method +func (m *MockRedshiftServerlessAPI) GetCustomDomainAssociationRequest(arg0 *redshiftserverless.GetCustomDomainAssociationInput) (*request.Request, *redshiftserverless.GetCustomDomainAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCustomDomainAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*redshiftserverless.GetCustomDomainAssociationOutput) + return ret0, ret1 +} + +// GetCustomDomainAssociationRequest indicates an expected call of GetCustomDomainAssociationRequest +func (mr *MockRedshiftServerlessAPIMockRecorder) GetCustomDomainAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomDomainAssociationRequest", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).GetCustomDomainAssociationRequest), arg0) +} + +// GetCustomDomainAssociationWithContext mocks base method +func (m *MockRedshiftServerlessAPI) GetCustomDomainAssociationWithContext(arg0 context.Context, arg1 *redshiftserverless.GetCustomDomainAssociationInput, arg2 ...request.Option) (*redshiftserverless.GetCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCustomDomainAssociationWithContext", varargs...) + ret0, _ := ret[0].(*redshiftserverless.GetCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCustomDomainAssociationWithContext indicates an expected call of GetCustomDomainAssociationWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) GetCustomDomainAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomDomainAssociationWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).GetCustomDomainAssociationWithContext), varargs...) +} + // GetEndpointAccess mocks base method func (m *MockRedshiftServerlessAPI) GetEndpointAccess(arg0 *redshiftserverless.GetEndpointAccessInput) (*redshiftserverless.GetEndpointAccessOutput, error) { m.ctrl.T.Helper() @@ -1085,6 +1235,89 @@ func (mr *MockRedshiftServerlessAPIMockRecorder) GetWorkgroupWithContext(arg0, a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkgroupWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).GetWorkgroupWithContext), varargs...) } +// ListCustomDomainAssociations mocks base method +func (m *MockRedshiftServerlessAPI) ListCustomDomainAssociations(arg0 *redshiftserverless.ListCustomDomainAssociationsInput) (*redshiftserverless.ListCustomDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCustomDomainAssociations", arg0) + ret0, _ := ret[0].(*redshiftserverless.ListCustomDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCustomDomainAssociations indicates an expected call of ListCustomDomainAssociations +func (mr *MockRedshiftServerlessAPIMockRecorder) ListCustomDomainAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomDomainAssociations", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ListCustomDomainAssociations), arg0) +} + +// ListCustomDomainAssociationsPages mocks base method +func (m *MockRedshiftServerlessAPI) ListCustomDomainAssociationsPages(arg0 *redshiftserverless.ListCustomDomainAssociationsInput, arg1 func(*redshiftserverless.ListCustomDomainAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCustomDomainAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCustomDomainAssociationsPages indicates an expected call of ListCustomDomainAssociationsPages +func (mr *MockRedshiftServerlessAPIMockRecorder) ListCustomDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomDomainAssociationsPages", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ListCustomDomainAssociationsPages), arg0, arg1) +} + +// ListCustomDomainAssociationsPagesWithContext mocks base method +func (m *MockRedshiftServerlessAPI) ListCustomDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *redshiftserverless.ListCustomDomainAssociationsInput, arg2 func(*redshiftserverless.ListCustomDomainAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCustomDomainAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCustomDomainAssociationsPagesWithContext indicates an expected call of ListCustomDomainAssociationsPagesWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) ListCustomDomainAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomDomainAssociationsPagesWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ListCustomDomainAssociationsPagesWithContext), varargs...) +} + +// ListCustomDomainAssociationsRequest mocks base method +func (m *MockRedshiftServerlessAPI) ListCustomDomainAssociationsRequest(arg0 *redshiftserverless.ListCustomDomainAssociationsInput) (*request.Request, *redshiftserverless.ListCustomDomainAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCustomDomainAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*redshiftserverless.ListCustomDomainAssociationsOutput) + return ret0, ret1 +} + +// ListCustomDomainAssociationsRequest indicates an expected call of ListCustomDomainAssociationsRequest +func (mr *MockRedshiftServerlessAPIMockRecorder) ListCustomDomainAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomDomainAssociationsRequest", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ListCustomDomainAssociationsRequest), arg0) +} + +// ListCustomDomainAssociationsWithContext mocks base method +func (m *MockRedshiftServerlessAPI) ListCustomDomainAssociationsWithContext(arg0 context.Context, arg1 *redshiftserverless.ListCustomDomainAssociationsInput, arg2 ...request.Option) (*redshiftserverless.ListCustomDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCustomDomainAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*redshiftserverless.ListCustomDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCustomDomainAssociationsWithContext indicates an expected call of ListCustomDomainAssociationsWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) ListCustomDomainAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomDomainAssociationsWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).ListCustomDomainAssociationsWithContext), varargs...) +} + // ListEndpointAccess mocks base method func (m *MockRedshiftServerlessAPI) ListEndpointAccess(arg0 *redshiftserverless.ListEndpointAccessInput) (*redshiftserverless.ListEndpointAccessOutput, error) { m.ctrl.T.Helper() @@ -2016,6 +2249,56 @@ func (mr *MockRedshiftServerlessAPIMockRecorder) UntagResourceWithContext(arg0, return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).UntagResourceWithContext), varargs...) } +// UpdateCustomDomainAssociation mocks base method +func (m *MockRedshiftServerlessAPI) UpdateCustomDomainAssociation(arg0 *redshiftserverless.UpdateCustomDomainAssociationInput) (*redshiftserverless.UpdateCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCustomDomainAssociation", arg0) + ret0, _ := ret[0].(*redshiftserverless.UpdateCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateCustomDomainAssociation indicates an expected call of UpdateCustomDomainAssociation +func (mr *MockRedshiftServerlessAPIMockRecorder) UpdateCustomDomainAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomDomainAssociation", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).UpdateCustomDomainAssociation), arg0) +} + +// UpdateCustomDomainAssociationRequest mocks base method +func (m *MockRedshiftServerlessAPI) UpdateCustomDomainAssociationRequest(arg0 *redshiftserverless.UpdateCustomDomainAssociationInput) (*request.Request, *redshiftserverless.UpdateCustomDomainAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCustomDomainAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*redshiftserverless.UpdateCustomDomainAssociationOutput) + return ret0, ret1 +} + +// UpdateCustomDomainAssociationRequest indicates an expected call of UpdateCustomDomainAssociationRequest +func (mr *MockRedshiftServerlessAPIMockRecorder) UpdateCustomDomainAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomDomainAssociationRequest", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).UpdateCustomDomainAssociationRequest), arg0) +} + +// UpdateCustomDomainAssociationWithContext mocks base method +func (m *MockRedshiftServerlessAPI) UpdateCustomDomainAssociationWithContext(arg0 context.Context, arg1 *redshiftserverless.UpdateCustomDomainAssociationInput, arg2 ...request.Option) (*redshiftserverless.UpdateCustomDomainAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateCustomDomainAssociationWithContext", varargs...) + ret0, _ := ret[0].(*redshiftserverless.UpdateCustomDomainAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateCustomDomainAssociationWithContext indicates an expected call of UpdateCustomDomainAssociationWithContext +func (mr *MockRedshiftServerlessAPIMockRecorder) UpdateCustomDomainAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomDomainAssociationWithContext", reflect.TypeOf((*MockRedshiftServerlessAPI)(nil).UpdateCustomDomainAssociationWithContext), varargs...) +} + // UpdateEndpointAccess mocks base method func (m *MockRedshiftServerlessAPI) UpdateEndpointAccess(arg0 *redshiftserverless.UpdateEndpointAccessInput) (*redshiftserverless.UpdateEndpointAccessOutput, error) { m.ctrl.T.Helper()