From ac92e249691539ddbb597ff34f68704829bfc53d Mon Sep 17 00:00:00 2001 From: alexlokshin-czi Date: Wed, 24 Apr 2024 20:18:22 +0000 Subject: [PATCH] Auto upgrade AWS Mocks --- aws/go.mod | 2 +- aws/go.sum | 4 +- aws/mocks/ec2.go | 100 +++++++++++++++++++++++++++++++++++++++++++++++ aws/mocks/ssm.go | 83 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 186 insertions(+), 3 deletions(-) diff --git a/aws/go.mod b/aws/go.mod index 58a2f41d..5568d3ca 100644 --- a/aws/go.mod +++ b/aws/go.mod @@ -5,7 +5,7 @@ go 1.21 toolchain go1.21.1 require ( - github.com/aws/aws-sdk-go v1.51.26 + github.com/aws/aws-sdk-go v1.51.28 github.com/golang/mock v1.6.0 github.com/pkg/errors v0.9.1 ) diff --git a/aws/go.sum b/aws/go.sum index c5ba44ee..383a21ab 100644 --- a/aws/go.sum +++ b/aws/go.sum @@ -1,5 +1,5 @@ -github.com/aws/aws-sdk-go v1.51.26 h1:fYud+95lh9B89fAlRtgYpY8CcJF4T7JrWkLMq4GGCOo= -github.com/aws/aws-sdk-go v1.51.26/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go v1.51.28 h1:x3CV5xjnL4EbVLaPXulBOxqiq2dkc9o6+50xxT3tvXY= +github.com/aws/aws-sdk-go v1.51.28/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= 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= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= diff --git a/aws/mocks/ec2.go b/aws/mocks/ec2.go index 258478c3..0529e9be 100644 --- a/aws/mocks/ec2.go +++ b/aws/mocks/ec2.go @@ -22913,6 +22913,56 @@ func (mr *MockEC2APIMockRecorder) DisableImageDeprecationWithContext(arg0, arg1 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationWithContext), varargs...) } +// DisableImageDeregistrationProtection mocks base method. +func (m *MockEC2API) DisableImageDeregistrationProtection(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*ec2.DisableImageDeregistrationProtectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableImageDeregistrationProtection", arg0) + ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableImageDeregistrationProtection indicates an expected call of DisableImageDeregistrationProtection. +func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtection), arg0) +} + +// DisableImageDeregistrationProtectionRequest mocks base method. +func (m *MockEC2API) DisableImageDeregistrationProtectionRequest(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*request.Request, *ec2.DisableImageDeregistrationProtectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableImageDeregistrationProtectionOutput) + return ret0, ret1 +} + +// DisableImageDeregistrationProtectionRequest indicates an expected call of DisableImageDeregistrationProtectionRequest. +func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtectionRequest), arg0) +} + +// DisableImageDeregistrationProtectionWithContext mocks base method. +func (m *MockEC2API) DisableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.DisableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.DisableImageDeregistrationProtectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableImageDeregistrationProtectionWithContext indicates an expected call of DisableImageDeregistrationProtectionWithContext. +func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtectionWithContext(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, "DisableImageDeregistrationProtectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtectionWithContext), varargs...) +} + // DisableImageRequest mocks base method. func (m *MockEC2API) DisableImageRequest(arg0 *ec2.DisableImageInput) (*request.Request, *ec2.DisableImageOutput) { m.ctrl.T.Helper() @@ -24413,6 +24463,56 @@ func (mr *MockEC2APIMockRecorder) EnableImageDeprecationWithContext(arg0, arg1 i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationWithContext), varargs...) } +// EnableImageDeregistrationProtection mocks base method. +func (m *MockEC2API) EnableImageDeregistrationProtection(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*ec2.EnableImageDeregistrationProtectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableImageDeregistrationProtection", arg0) + ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableImageDeregistrationProtection indicates an expected call of EnableImageDeregistrationProtection. +func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtection), arg0) +} + +// EnableImageDeregistrationProtectionRequest mocks base method. +func (m *MockEC2API) EnableImageDeregistrationProtectionRequest(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*request.Request, *ec2.EnableImageDeregistrationProtectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableImageDeregistrationProtectionOutput) + return ret0, ret1 +} + +// EnableImageDeregistrationProtectionRequest indicates an expected call of EnableImageDeregistrationProtectionRequest. +func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtectionRequest), arg0) +} + +// EnableImageDeregistrationProtectionWithContext mocks base method. +func (m *MockEC2API) EnableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.EnableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.EnableImageDeregistrationProtectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableImageDeregistrationProtectionWithContext indicates an expected call of EnableImageDeregistrationProtectionWithContext. +func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtectionWithContext(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, "EnableImageDeregistrationProtectionWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtectionWithContext), varargs...) +} + // EnableImageRequest mocks base method. func (m *MockEC2API) EnableImageRequest(arg0 *ec2.EnableImageInput) (*request.Request, *ec2.EnableImageOutput) { m.ctrl.T.Helper() diff --git a/aws/mocks/ssm.go b/aws/mocks/ssm.go index 780991c6..508beac5 100644 --- a/aws/mocks/ssm.go +++ b/aws/mocks/ssm.go @@ -2715,6 +2715,89 @@ func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchesWithContext(arg0, arg1 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchesWithContext), varargs...) } +// DescribeInstanceProperties mocks base method. +func (m *MockSSMAPI) DescribeInstanceProperties(arg0 *ssm.DescribeInstancePropertiesInput) (*ssm.DescribeInstancePropertiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceProperties", arg0) + ret0, _ := ret[0].(*ssm.DescribeInstancePropertiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceProperties indicates an expected call of DescribeInstanceProperties. +func (mr *MockSSMAPIMockRecorder) DescribeInstanceProperties(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceProperties", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceProperties), arg0) +} + +// DescribeInstancePropertiesPages mocks base method. +func (m *MockSSMAPI) DescribeInstancePropertiesPages(arg0 *ssm.DescribeInstancePropertiesInput, arg1 func(*ssm.DescribeInstancePropertiesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancePropertiesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancePropertiesPages indicates an expected call of DescribeInstancePropertiesPages. +func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesPages), arg0, arg1) +} + +// DescribeInstancePropertiesPagesWithContext mocks base method. +func (m *MockSSMAPI) DescribeInstancePropertiesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePropertiesInput, arg2 func(*ssm.DescribeInstancePropertiesOutput, 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, "DescribeInstancePropertiesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancePropertiesPagesWithContext indicates an expected call of DescribeInstancePropertiesPagesWithContext. +func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesPagesWithContext(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, "DescribeInstancePropertiesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesPagesWithContext), varargs...) +} + +// DescribeInstancePropertiesRequest mocks base method. +func (m *MockSSMAPI) DescribeInstancePropertiesRequest(arg0 *ssm.DescribeInstancePropertiesInput) (*request.Request, *ssm.DescribeInstancePropertiesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancePropertiesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ssm.DescribeInstancePropertiesOutput) + return ret0, ret1 +} + +// DescribeInstancePropertiesRequest indicates an expected call of DescribeInstancePropertiesRequest. +func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesRequest), arg0) +} + +// DescribeInstancePropertiesWithContext mocks base method. +func (m *MockSSMAPI) DescribeInstancePropertiesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePropertiesInput, arg2 ...request.Option) (*ssm.DescribeInstancePropertiesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstancePropertiesWithContext", varargs...) + ret0, _ := ret[0].(*ssm.DescribeInstancePropertiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstancePropertiesWithContext indicates an expected call of DescribeInstancePropertiesWithContext. +func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesWithContext(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, "DescribeInstancePropertiesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesWithContext), varargs...) +} + // DescribeInventoryDeletions mocks base method. func (m *MockSSMAPI) DescribeInventoryDeletions(arg0 *ssm.DescribeInventoryDeletionsInput) (*ssm.DescribeInventoryDeletionsOutput, error) { m.ctrl.T.Helper()