From 1335ab9295e6f10f3fef8db53b171dccc36e2db5 Mon Sep 17 00:00:00 2001 From: Repository CI Date: Wed, 1 Nov 2023 02:30:45 +0000 Subject: [PATCH] Automatic ci update Version into v1.47.0 --- aws-sdk.version | 2 +- go.mod | 2 +- go.sum | 2 + service/amplifymock/mock.go | 132 +++++++++++++++++++++++++++++++++++ service/ec2mock/mock.go | 133 ++++++++++++++++++++++++++++++++++++ 5 files changed, 269 insertions(+), 2 deletions(-) diff --git a/aws-sdk.version b/aws-sdk.version index 2f58ae1e..7a536ce1 100755 --- a/aws-sdk.version +++ b/aws-sdk.version @@ -1 +1 @@ -v1.46.7 +v1.47.0 diff --git a/go.mod b/go.mod index 328e9e17..fbf54c26 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.7 + github.com/aws/aws-sdk-go v1.47.0 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 fe314aab..feec992e 100644 --- a/go.sum +++ b/go.sum @@ -2296,6 +2296,8 @@ 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/aws/aws-sdk-go v1.47.0 h1:/JUg9V1+xh+qBn8A6ec/l15ETPaMaBqxkjz+gg63dNk= +github.com/aws/aws-sdk-go v1.47.0/go.mod h1:DlEaEbWKZmsITVbqlSVvekPARM1HzeV9PMYg15ymSDA= 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/amplifymock/mock.go b/service/amplifymock/mock.go index 907710cc..62573983 100644 --- a/service/amplifymock/mock.go +++ b/service/amplifymock/mock.go @@ -1050,6 +1050,39 @@ func (mr *MockAmplifyAPIMockRecorder) ListApps(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApps", reflect.TypeOf((*MockAmplifyAPI)(nil).ListApps), arg0) } +// ListAppsPages mocks base method +func (m *MockAmplifyAPI) ListAppsPages(arg0 *amplify.ListAppsInput, arg1 func(*amplify.ListAppsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAppsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAppsPages indicates an expected call of ListAppsPages +func (mr *MockAmplifyAPIMockRecorder) ListAppsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAppsPages", reflect.TypeOf((*MockAmplifyAPI)(nil).ListAppsPages), arg0, arg1) +} + +// ListAppsPagesWithContext mocks base method +func (m *MockAmplifyAPI) ListAppsPagesWithContext(arg0 context.Context, arg1 *amplify.ListAppsInput, arg2 func(*amplify.ListAppsOutput, 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, "ListAppsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAppsPagesWithContext indicates an expected call of ListAppsPagesWithContext +func (mr *MockAmplifyAPIMockRecorder) ListAppsPagesWithContext(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, "ListAppsPagesWithContext", reflect.TypeOf((*MockAmplifyAPI)(nil).ListAppsPagesWithContext), varargs...) +} + // ListAppsRequest mocks base method func (m *MockAmplifyAPI) ListAppsRequest(arg0 *amplify.ListAppsInput) (*request.Request, *amplify.ListAppsOutput) { m.ctrl.T.Helper() @@ -1200,6 +1233,39 @@ func (mr *MockAmplifyAPIMockRecorder) ListBranches(arg0 interface{}) *gomock.Cal return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockAmplifyAPI)(nil).ListBranches), arg0) } +// ListBranchesPages mocks base method +func (m *MockAmplifyAPI) ListBranchesPages(arg0 *amplify.ListBranchesInput, arg1 func(*amplify.ListBranchesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBranchesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListBranchesPages indicates an expected call of ListBranchesPages +func (mr *MockAmplifyAPIMockRecorder) ListBranchesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranchesPages", reflect.TypeOf((*MockAmplifyAPI)(nil).ListBranchesPages), arg0, arg1) +} + +// ListBranchesPagesWithContext mocks base method +func (m *MockAmplifyAPI) ListBranchesPagesWithContext(arg0 context.Context, arg1 *amplify.ListBranchesInput, arg2 func(*amplify.ListBranchesOutput, 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, "ListBranchesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListBranchesPagesWithContext indicates an expected call of ListBranchesPagesWithContext +func (mr *MockAmplifyAPIMockRecorder) ListBranchesPagesWithContext(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, "ListBranchesPagesWithContext", reflect.TypeOf((*MockAmplifyAPI)(nil).ListBranchesPagesWithContext), varargs...) +} + // ListBranchesRequest mocks base method func (m *MockAmplifyAPI) ListBranchesRequest(arg0 *amplify.ListBranchesInput) (*request.Request, *amplify.ListBranchesOutput) { m.ctrl.T.Helper() @@ -1250,6 +1316,39 @@ func (mr *MockAmplifyAPIMockRecorder) ListDomainAssociations(arg0 interface{}) * return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomainAssociations", reflect.TypeOf((*MockAmplifyAPI)(nil).ListDomainAssociations), arg0) } +// ListDomainAssociationsPages mocks base method +func (m *MockAmplifyAPI) ListDomainAssociationsPages(arg0 *amplify.ListDomainAssociationsInput, arg1 func(*amplify.ListDomainAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDomainAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDomainAssociationsPages indicates an expected call of ListDomainAssociationsPages +func (mr *MockAmplifyAPIMockRecorder) ListDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomainAssociationsPages", reflect.TypeOf((*MockAmplifyAPI)(nil).ListDomainAssociationsPages), arg0, arg1) +} + +// ListDomainAssociationsPagesWithContext mocks base method +func (m *MockAmplifyAPI) ListDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *amplify.ListDomainAssociationsInput, arg2 func(*amplify.ListDomainAssociationsOutput, 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, "ListDomainAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDomainAssociationsPagesWithContext indicates an expected call of ListDomainAssociationsPagesWithContext +func (mr *MockAmplifyAPIMockRecorder) ListDomainAssociationsPagesWithContext(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, "ListDomainAssociationsPagesWithContext", reflect.TypeOf((*MockAmplifyAPI)(nil).ListDomainAssociationsPagesWithContext), varargs...) +} + // ListDomainAssociationsRequest mocks base method func (m *MockAmplifyAPI) ListDomainAssociationsRequest(arg0 *amplify.ListDomainAssociationsInput) (*request.Request, *amplify.ListDomainAssociationsOutput) { m.ctrl.T.Helper() @@ -1300,6 +1399,39 @@ func (mr *MockAmplifyAPIMockRecorder) ListJobs(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListJobs", reflect.TypeOf((*MockAmplifyAPI)(nil).ListJobs), arg0) } +// ListJobsPages mocks base method +func (m *MockAmplifyAPI) ListJobsPages(arg0 *amplify.ListJobsInput, arg1 func(*amplify.ListJobsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListJobsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListJobsPages indicates an expected call of ListJobsPages +func (mr *MockAmplifyAPIMockRecorder) ListJobsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListJobsPages", reflect.TypeOf((*MockAmplifyAPI)(nil).ListJobsPages), arg0, arg1) +} + +// ListJobsPagesWithContext mocks base method +func (m *MockAmplifyAPI) ListJobsPagesWithContext(arg0 context.Context, arg1 *amplify.ListJobsInput, arg2 func(*amplify.ListJobsOutput, 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, "ListJobsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListJobsPagesWithContext indicates an expected call of ListJobsPagesWithContext +func (mr *MockAmplifyAPIMockRecorder) ListJobsPagesWithContext(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, "ListJobsPagesWithContext", reflect.TypeOf((*MockAmplifyAPI)(nil).ListJobsPagesWithContext), varargs...) +} + // ListJobsRequest mocks base method func (m *MockAmplifyAPI) ListJobsRequest(arg0 *amplify.ListJobsInput) (*request.Request, *amplify.ListJobsOutput) { m.ctrl.T.Helper() diff --git a/service/ec2mock/mock.go b/service/ec2mock/mock.go index 171ba323..2195d661 100644 --- a/service/ec2mock/mock.go +++ b/service/ec2mock/mock.go @@ -11467,6 +11467,89 @@ func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsWithContext(arg0, arg1 inter return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsWithContext), varargs...) } +// DescribeCapacityBlockOfferings mocks base method +func (m *MockEC2API) DescribeCapacityBlockOfferings(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*ec2.DescribeCapacityBlockOfferingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferings", arg0) + ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCapacityBlockOfferings indicates an expected call of DescribeCapacityBlockOfferings +func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferings), arg0) +} + +// DescribeCapacityBlockOfferingsPages mocks base method +func (m *MockEC2API) DescribeCapacityBlockOfferingsPages(arg0 *ec2.DescribeCapacityBlockOfferingsInput, arg1 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCapacityBlockOfferingsPages indicates an expected call of DescribeCapacityBlockOfferingsPages +func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsPages), arg0, arg1) +} + +// DescribeCapacityBlockOfferingsPagesWithContext mocks base method +func (m *MockEC2API) DescribeCapacityBlockOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 func(*ec2.DescribeCapacityBlockOfferingsOutput, 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, "DescribeCapacityBlockOfferingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCapacityBlockOfferingsPagesWithContext indicates an expected call of DescribeCapacityBlockOfferingsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsPagesWithContext(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, "DescribeCapacityBlockOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsPagesWithContext), varargs...) +} + +// DescribeCapacityBlockOfferingsRequest mocks base method +func (m *MockEC2API) DescribeCapacityBlockOfferingsRequest(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*request.Request, *ec2.DescribeCapacityBlockOfferingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeCapacityBlockOfferingsOutput) + return ret0, ret1 +} + +// DescribeCapacityBlockOfferingsRequest indicates an expected call of DescribeCapacityBlockOfferingsRequest +func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsRequest), arg0) +} + +// DescribeCapacityBlockOfferingsWithContext mocks base method +func (m *MockEC2API) DescribeCapacityBlockOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 ...request.Option) (*ec2.DescribeCapacityBlockOfferingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCapacityBlockOfferingsWithContext indicates an expected call of DescribeCapacityBlockOfferingsWithContext +func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsWithContext(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, "DescribeCapacityBlockOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsWithContext), varargs...) +} + // DescribeCapacityReservationFleets mocks base method func (m *MockEC2API) DescribeCapacityReservationFleets(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*ec2.DescribeCapacityReservationFleetsOutput, error) { m.ctrl.T.Helper() @@ -31440,6 +31523,56 @@ func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidrWithContext(arg0, a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidrWithContext), varargs...) } +// PurchaseCapacityBlock mocks base method +func (m *MockEC2API) PurchaseCapacityBlock(arg0 *ec2.PurchaseCapacityBlockInput) (*ec2.PurchaseCapacityBlockOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseCapacityBlock", arg0) + ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseCapacityBlock indicates an expected call of PurchaseCapacityBlock +func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlock", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlock), arg0) +} + +// PurchaseCapacityBlockRequest mocks base method +func (m *MockEC2API) PurchaseCapacityBlockRequest(arg0 *ec2.PurchaseCapacityBlockInput) (*request.Request, *ec2.PurchaseCapacityBlockOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseCapacityBlockRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.PurchaseCapacityBlockOutput) + return ret0, ret1 +} + +// PurchaseCapacityBlockRequest indicates an expected call of PurchaseCapacityBlockRequest +func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlockRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlockRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlockRequest), arg0) +} + +// PurchaseCapacityBlockWithContext mocks base method +func (m *MockEC2API) PurchaseCapacityBlockWithContext(arg0 context.Context, arg1 *ec2.PurchaseCapacityBlockInput, arg2 ...request.Option) (*ec2.PurchaseCapacityBlockOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PurchaseCapacityBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseCapacityBlockWithContext indicates an expected call of PurchaseCapacityBlockWithContext +func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlockWithContext(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, "PurchaseCapacityBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlockWithContext), varargs...) +} + // PurchaseHostReservation mocks base method func (m *MockEC2API) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) { m.ctrl.T.Helper()