From 70244c6ff715da7ee20b6d17c4cc16b04f13731d Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Fri, 25 Jun 2021 15:42:28 -0500 Subject: [PATCH 1/8] Bump package versions --- aws/mocks/EC2API.go | 2253 +++++++++++++++++++++++++++++++++++++++---- go.mod | 6 +- go.sum | 47 +- 3 files changed, 2130 insertions(+), 176 deletions(-) diff --git a/aws/mocks/EC2API.go b/aws/mocks/EC2API.go index cb5f40d6..f8e3f0e6 100644 --- a/aws/mocks/EC2API.go +++ b/aws/mocks/EC2API.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: vendor/github.com/aws/aws-sdk-go@v1.34.27/service/ec2/ec2iface/interface.go +// Source: /Users/yoriy/go/pkg/mod/github.com/aws/aws-sdk-go@v1.38.68/service/ec2/ec2iface/interface.go // Package mock_ec2iface is a generated GoMock package. package mock_ec2iface @@ -86,6 +86,56 @@ func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteWithContex return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...) } +// AcceptTransitGatewayMulticastDomainAssociations mocks base method. +func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociations(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociations", arg0) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayMulticastDomainAssociations indicates an expected call of AcceptTransitGatewayMulticastDomainAssociations. +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociations), arg0) +} + +// AcceptTransitGatewayMulticastDomainAssociationsRequest mocks base method. +func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) + return ret0, ret1 +} + +// AcceptTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of AcceptTransitGatewayMulticastDomainAssociationsRequest. +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociationsRequest), arg0) +} + +// AcceptTransitGatewayMulticastDomainAssociationsWithContext mocks base method. +func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsWithContext(arg0 aws.Context, arg1 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of AcceptTransitGatewayMulticastDomainAssociationsWithContext. +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociationsWithContext(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, "AcceptTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociationsWithContext), varargs...) +} + // AcceptTransitGatewayPeeringAttachment mocks base method. func (m *MockEC2API) AcceptTransitGatewayPeeringAttachment(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) { m.ctrl.T.Helper() @@ -736,6 +786,56 @@ func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsWithContext(arg0, arg1 int return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsWithContext), varargs...) } +// AssociateEnclaveCertificateIamRole mocks base method. +func (m *MockEC2API) AssociateEnclaveCertificateIamRole(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRole", arg0) + ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateEnclaveCertificateIamRole indicates an expected call of AssociateEnclaveCertificateIamRole. +func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRole), arg0) +} + +// AssociateEnclaveCertificateIamRoleRequest mocks base method. +func (m *MockEC2API) AssociateEnclaveCertificateIamRoleRequest(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.AssociateEnclaveCertificateIamRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateEnclaveCertificateIamRoleOutput) + return ret0, ret1 +} + +// AssociateEnclaveCertificateIamRoleRequest indicates an expected call of AssociateEnclaveCertificateIamRoleRequest. +func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRoleRequest), arg0) +} + +// AssociateEnclaveCertificateIamRoleWithContext mocks base method. +func (m *MockEC2API) AssociateEnclaveCertificateIamRoleWithContext(arg0 aws.Context, arg1 *ec2.AssociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateEnclaveCertificateIamRoleWithContext indicates an expected call of AssociateEnclaveCertificateIamRoleWithContext. +func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRoleWithContext(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, "AssociateEnclaveCertificateIamRoleWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRoleWithContext), varargs...) +} + // AssociateIamInstanceProfile mocks base method. func (m *MockEC2API) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) { m.ctrl.T.Helper() @@ -986,6 +1086,56 @@ func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableWithContext(a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...) } +// AssociateTrunkInterface mocks base method. +func (m *MockEC2API) AssociateTrunkInterface(arg0 *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTrunkInterface", arg0) + ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTrunkInterface indicates an expected call of AssociateTrunkInterface. +func (mr *MockEC2APIMockRecorder) AssociateTrunkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterface), arg0) +} + +// AssociateTrunkInterfaceRequest mocks base method. +func (m *MockEC2API) AssociateTrunkInterfaceRequest(arg0 *ec2.AssociateTrunkInterfaceInput) (*request.Request, *ec2.AssociateTrunkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTrunkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateTrunkInterfaceOutput) + return ret0, ret1 +} + +// AssociateTrunkInterfaceRequest indicates an expected call of AssociateTrunkInterfaceRequest. +func (mr *MockEC2APIMockRecorder) AssociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterfaceRequest), arg0) +} + +// AssociateTrunkInterfaceWithContext mocks base method. +func (m *MockEC2API) AssociateTrunkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.AssociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.AssociateTrunkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateTrunkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTrunkInterfaceWithContext indicates an expected call of AssociateTrunkInterfaceWithContext. +func (mr *MockEC2APIMockRecorder) AssociateTrunkInterfaceWithContext(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, "AssociateTrunkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterfaceWithContext), varargs...) +} + // AssociateVpcCidrBlock mocks base method. func (m *MockEC2API) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) { m.ctrl.T.Helper() @@ -3286,6 +3436,56 @@ func (mr *MockEC2APIMockRecorder) CreateNetworkAclWithContext(arg0, arg1 interfa return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclWithContext), varargs...) } +// CreateNetworkInsightsPath mocks base method. +func (m *MockEC2API) CreateNetworkInsightsPath(arg0 *ec2.CreateNetworkInsightsPathInput) (*ec2.CreateNetworkInsightsPathOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInsightsPath", arg0) + ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInsightsPath indicates an expected call of CreateNetworkInsightsPath. +func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPath(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPath), arg0) +} + +// CreateNetworkInsightsPathRequest mocks base method. +func (m *MockEC2API) CreateNetworkInsightsPathRequest(arg0 *ec2.CreateNetworkInsightsPathInput) (*request.Request, *ec2.CreateNetworkInsightsPathOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInsightsPathRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNetworkInsightsPathOutput) + return ret0, ret1 +} + +// CreateNetworkInsightsPathRequest indicates an expected call of CreateNetworkInsightsPathRequest. +func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPathRequest), arg0) +} + +// CreateNetworkInsightsPathWithContext mocks base method. +func (m *MockEC2API) CreateNetworkInsightsPathWithContext(arg0 aws.Context, arg1 *ec2.CreateNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsPathOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNetworkInsightsPathWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInsightsPathWithContext indicates an expected call of CreateNetworkInsightsPathWithContext. +func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPathWithContext(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, "CreateNetworkInsightsPathWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPathWithContext), varargs...) +} + // CreateNetworkInterface mocks base method. func (m *MockEC2API) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { m.ctrl.T.Helper() @@ -3436,6 +3636,56 @@ func (mr *MockEC2APIMockRecorder) CreatePlacementGroupWithContext(arg0, arg1 int return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...) } +// CreateReplaceRootVolumeTask mocks base method. +func (m *MockEC2API) CreateReplaceRootVolumeTask(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*ec2.CreateReplaceRootVolumeTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTask", arg0) + ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReplaceRootVolumeTask indicates an expected call of CreateReplaceRootVolumeTask. +func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTask", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTask), arg0) +} + +// CreateReplaceRootVolumeTaskRequest mocks base method. +func (m *MockEC2API) CreateReplaceRootVolumeTaskRequest(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*request.Request, *ec2.CreateReplaceRootVolumeTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateReplaceRootVolumeTaskOutput) + return ret0, ret1 +} + +// CreateReplaceRootVolumeTaskRequest indicates an expected call of CreateReplaceRootVolumeTaskRequest. +func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskRequest), arg0) +} + +// CreateReplaceRootVolumeTaskWithContext mocks base method. +func (m *MockEC2API) CreateReplaceRootVolumeTaskWithContext(arg0 aws.Context, arg1 *ec2.CreateReplaceRootVolumeTaskInput, arg2 ...request.Option) (*ec2.CreateReplaceRootVolumeTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReplaceRootVolumeTaskWithContext indicates an expected call of CreateReplaceRootVolumeTaskWithContext. +func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskWithContext(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, "CreateReplaceRootVolumeTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskWithContext), varargs...) +} + // CreateReservedInstancesListing mocks base method. func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) { m.ctrl.T.Helper() @@ -3486,6 +3736,56 @@ func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingWithContext(arg0 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingWithContext), varargs...) } +// CreateRestoreImageTask mocks base method. +func (m *MockEC2API) CreateRestoreImageTask(arg0 *ec2.CreateRestoreImageTaskInput) (*ec2.CreateRestoreImageTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRestoreImageTask", arg0) + ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRestoreImageTask indicates an expected call of CreateRestoreImageTask. +func (mr *MockEC2APIMockRecorder) CreateRestoreImageTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTask), arg0) +} + +// CreateRestoreImageTaskRequest mocks base method. +func (m *MockEC2API) CreateRestoreImageTaskRequest(arg0 *ec2.CreateRestoreImageTaskInput) (*request.Request, *ec2.CreateRestoreImageTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRestoreImageTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateRestoreImageTaskOutput) + return ret0, ret1 +} + +// CreateRestoreImageTaskRequest indicates an expected call of CreateRestoreImageTaskRequest. +func (mr *MockEC2APIMockRecorder) CreateRestoreImageTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTaskRequest), arg0) +} + +// CreateRestoreImageTaskWithContext mocks base method. +func (m *MockEC2API) CreateRestoreImageTaskWithContext(arg0 aws.Context, arg1 *ec2.CreateRestoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateRestoreImageTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRestoreImageTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRestoreImageTaskWithContext indicates an expected call of CreateRestoreImageTaskWithContext. +func (mr *MockEC2APIMockRecorder) CreateRestoreImageTaskWithContext(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, "CreateRestoreImageTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTaskWithContext), varargs...) +} + // CreateRoute mocks base method. func (m *MockEC2API) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) { m.ctrl.T.Helper() @@ -3786,6 +4086,56 @@ func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionWithContext(arg0 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...) } +// CreateStoreImageTask mocks base method. +func (m *MockEC2API) CreateStoreImageTask(arg0 *ec2.CreateStoreImageTaskInput) (*ec2.CreateStoreImageTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateStoreImageTask", arg0) + ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateStoreImageTask indicates an expected call of CreateStoreImageTask. +func (mr *MockEC2APIMockRecorder) CreateStoreImageTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTask), arg0) +} + +// CreateStoreImageTaskRequest mocks base method. +func (m *MockEC2API) CreateStoreImageTaskRequest(arg0 *ec2.CreateStoreImageTaskInput) (*request.Request, *ec2.CreateStoreImageTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateStoreImageTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateStoreImageTaskOutput) + return ret0, ret1 +} + +// CreateStoreImageTaskRequest indicates an expected call of CreateStoreImageTaskRequest. +func (mr *MockEC2APIMockRecorder) CreateStoreImageTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTaskRequest), arg0) +} + +// CreateStoreImageTaskWithContext mocks base method. +func (m *MockEC2API) CreateStoreImageTaskWithContext(arg0 aws.Context, arg1 *ec2.CreateStoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateStoreImageTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateStoreImageTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateStoreImageTaskWithContext indicates an expected call of CreateStoreImageTaskWithContext. +func (mr *MockEC2APIMockRecorder) CreateStoreImageTaskWithContext(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, "CreateStoreImageTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTaskWithContext), varargs...) +} + // CreateSubnet mocks base method. func (m *MockEC2API) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) { m.ctrl.T.Helper() @@ -4101,95 +4451,195 @@ func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0) } -// CreateTransitGatewayMulticastDomain mocks base method. -func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { +// CreateTransitGatewayConnect mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnect(arg0 *ec2.CreateTransitGatewayConnectInput) (*ec2.CreateTransitGatewayConnectOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret := m.ctrl.Call(m, "CreateTransitGatewayConnect", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain. -func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { +// CreateTransitGatewayConnect indicates an expected call of CreateTransitGatewayConnect. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnect(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnect), arg0) } -// CreateTransitGatewayMulticastDomainRequest mocks base method. -func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) { +// CreateTransitGatewayConnectPeer mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnectPeer(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*ec2.CreateTransitGatewayConnectPeerOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeer", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest. -func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { +// CreateTransitGatewayConnectPeer indicates an expected call of CreateTransitGatewayConnectPeer. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeer), arg0) } -// CreateTransitGatewayMulticastDomainWithContext mocks base method. -func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { +// CreateTransitGatewayConnectPeerRequest mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnectPeerRequest(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*request.Request, *ec2.CreateTransitGatewayConnectPeerOutput) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) + ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectPeerOutput) return ret0, ret1 } -// CreateTransitGatewayMulticastDomainWithContext indicates an expected call of CreateTransitGatewayMulticastDomainWithContext. -func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// CreateTransitGatewayConnectPeerRequest indicates an expected call of CreateTransitGatewayConnectPeerRequest. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeerRequest), arg0) } -// CreateTransitGatewayPeeringAttachment mocks base method. -func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { +// CreateTransitGatewayConnectPeerWithContext mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnectPeerWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectPeerOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment. -func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { +// CreateTransitGatewayConnectPeerWithContext indicates an expected call of CreateTransitGatewayConnectPeerWithContext. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0) + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeerWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeerWithContext), varargs...) } -// CreateTransitGatewayPeeringAttachmentRequest mocks base method. -func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) { +// CreateTransitGatewayConnectRequest mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnectRequest(arg0 *ec2.CreateTransitGatewayConnectInput) (*request.Request, *ec2.CreateTransitGatewayConnectOutput) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0) + ret := m.ctrl.Call(m, "CreateTransitGatewayConnectRequest", arg0) ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectOutput) return ret0, ret1 } -// CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest. -func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { +// CreateTransitGatewayConnectRequest indicates an expected call of CreateTransitGatewayConnectRequest. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectRequest), arg0) } -// CreateTransitGatewayPeeringAttachmentWithContext mocks base method. -func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { +// CreateTransitGatewayConnectWithContext mocks base method. +func (m *MockEC2API) CreateTransitGatewayConnectWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + ret := m.ctrl.Call(m, "CreateTransitGatewayConnectWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayConnectWithContext indicates an expected call of CreateTransitGatewayConnectWithContext. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectWithContext(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, "CreateTransitGatewayConnectWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectWithContext), varargs...) +} + +// CreateTransitGatewayMulticastDomain mocks base method. +func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0) +} + +// CreateTransitGatewayMulticastDomainRequest mocks base method. +func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0) +} + +// CreateTransitGatewayMulticastDomainWithContext mocks base method. +func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomainWithContext indicates an expected call of CreateTransitGatewayMulticastDomainWithContext. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainWithContext(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, "CreateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...) +} + +// CreateTransitGatewayPeeringAttachment mocks base method. +func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0) +} + +// CreateTransitGatewayPeeringAttachmentRequest mocks base method. +func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + return ret0, ret1 +} + +// CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest. +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0) +} + +// CreateTransitGatewayPeeringAttachmentWithContext mocks base method. +func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -5836,6 +6286,106 @@ func (mr *MockEC2APIMockRecorder) DeleteNetworkAclWithContext(arg0, arg1 interfa return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclWithContext), varargs...) } +// DeleteNetworkInsightsAnalysis mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsAnalysis(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysis", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInsightsAnalysis indicates an expected call of DeleteNetworkInsightsAnalysis. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysis), arg0) +} + +// DeleteNetworkInsightsAnalysisRequest mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAnalysisOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAnalysisOutput) + return ret0, ret1 +} + +// DeleteNetworkInsightsAnalysisRequest indicates an expected call of DeleteNetworkInsightsAnalysisRequest. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysisRequest), arg0) +} + +// DeleteNetworkInsightsAnalysisWithContext mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsAnalysisWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInsightsAnalysisWithContext indicates an expected call of DeleteNetworkInsightsAnalysisWithContext. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysisWithContext(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, "DeleteNetworkInsightsAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysisWithContext), varargs...) +} + +// DeleteNetworkInsightsPath mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsPath(arg0 *ec2.DeleteNetworkInsightsPathInput) (*ec2.DeleteNetworkInsightsPathOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInsightsPath", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInsightsPath indicates an expected call of DeleteNetworkInsightsPath. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPath(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPath), arg0) +} + +// DeleteNetworkInsightsPathRequest mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsPathRequest(arg0 *ec2.DeleteNetworkInsightsPathInput) (*request.Request, *ec2.DeleteNetworkInsightsPathOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsPathOutput) + return ret0, ret1 +} + +// DeleteNetworkInsightsPathRequest indicates an expected call of DeleteNetworkInsightsPathRequest. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPathRequest), arg0) +} + +// DeleteNetworkInsightsPathWithContext mocks base method. +func (m *MockEC2API) DeleteNetworkInsightsPathWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsPathOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInsightsPathWithContext indicates an expected call of DeleteNetworkInsightsPathWithContext. +func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPathWithContext(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, "DeleteNetworkInsightsPathWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPathWithContext), varargs...) +} + // DeleteNetworkInterface mocks base method. func (m *MockEC2API) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { m.ctrl.T.Helper() @@ -6601,6 +7151,106 @@ func (mr *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0) } +// DeleteTransitGatewayConnect mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnect(arg0 *ec2.DeleteTransitGatewayConnectInput) (*ec2.DeleteTransitGatewayConnectOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnect", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayConnect indicates an expected call of DeleteTransitGatewayConnect. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnect(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnect), arg0) +} + +// DeleteTransitGatewayConnectPeer mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnectPeer(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeer", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayConnectPeer indicates an expected call of DeleteTransitGatewayConnectPeer. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeer), arg0) +} + +// DeleteTransitGatewayConnectPeerRequest mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnectPeerRequest(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*request.Request, *ec2.DeleteTransitGatewayConnectPeerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectPeerOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayConnectPeerRequest indicates an expected call of DeleteTransitGatewayConnectPeerRequest. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeerRequest), arg0) +} + +// DeleteTransitGatewayConnectPeerWithContext mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnectPeerWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayConnectPeerWithContext indicates an expected call of DeleteTransitGatewayConnectPeerWithContext. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeerWithContext(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, "DeleteTransitGatewayConnectPeerWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeerWithContext), varargs...) +} + +// DeleteTransitGatewayConnectRequest mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnectRequest(arg0 *ec2.DeleteTransitGatewayConnectInput) (*request.Request, *ec2.DeleteTransitGatewayConnectOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayConnectRequest indicates an expected call of DeleteTransitGatewayConnectRequest. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectRequest), arg0) +} + +// DeleteTransitGatewayConnectWithContext mocks base method. +func (m *MockEC2API) DeleteTransitGatewayConnectWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayConnectWithContext indicates an expected call of DeleteTransitGatewayConnectWithContext. +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectWithContext(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, "DeleteTransitGatewayConnectWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectWithContext), varargs...) +} + // DeleteTransitGatewayMulticastDomain mocks base method. func (m *MockEC2API) DeleteTransitGatewayMulticastDomain(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { m.ctrl.T.Helper() @@ -7701,54 +8351,137 @@ func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Ca return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0) } -// DescribeAddressesRequest mocks base method. -func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) { +// DescribeAddressesAttribute mocks base method. +func (m *MockEC2API) DescribeAddressesAttribute(arg0 *ec2.DescribeAddressesAttributeInput) (*ec2.DescribeAddressesAttributeOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAddressesOutput) + ret := m.ctrl.Call(m, "DescribeAddressesAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest. -func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { +// DescribeAddressesAttribute indicates an expected call of DescribeAddressesAttribute. +func (mr *MockEC2APIMockRecorder) DescribeAddressesAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttribute), arg0) } -// DescribeAddressesWithContext mocks base method. -func (m *MockEC2API) DescribeAddressesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) { +// DescribeAddressesAttributePages mocks base method. +func (m *MockEC2API) DescribeAddressesAttributePages(arg0 *ec2.DescribeAddressesAttributeInput, arg1 func(*ec2.DescribeAddressesAttributeOutput, bool) bool) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + ret := m.ctrl.Call(m, "DescribeAddressesAttributePages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAddressesAttributePages indicates an expected call of DescribeAddressesAttributePages. +func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributePages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributePages", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributePages), arg0, arg1) +} + +// DescribeAddressesAttributePagesWithContext mocks base method. +func (m *MockEC2API) DescribeAddressesAttributePagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 func(*ec2.DescribeAddressesAttributeOutput, 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, "DescribeAddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "DescribeAddressesAttributePagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 } -// DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext. -func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeAddressesAttributePagesWithContext indicates an expected call of DescribeAddressesAttributePagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...) + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributePagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributePagesWithContext), varargs...) } -// DescribeAggregateIdFormat mocks base method. -func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) { +// DescribeAddressesAttributeRequest mocks base method. +func (m *MockEC2API) DescribeAddressesAttributeRequest(arg0 *ec2.DescribeAddressesAttributeInput) (*request.Request, *ec2.DescribeAddressesAttributeOutput) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0) - ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) - ret1, _ := ret[1].(error) + ret := m.ctrl.Call(m, "DescribeAddressesAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAddressesAttributeOutput) return ret0, ret1 } -// DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat. -func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { +// DescribeAddressesAttributeRequest indicates an expected call of DescribeAddressesAttributeRequest. +func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributeRequest), arg0) +} + +// DescribeAddressesAttributeWithContext mocks base method. +func (m *MockEC2API) DescribeAddressesAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 ...request.Option) (*ec2.DescribeAddressesAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAddressesAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAddressesAttributeWithContext indicates an expected call of DescribeAddressesAttributeWithContext. +func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributeWithContext(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, "DescribeAddressesAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributeWithContext), varargs...) +} + +// DescribeAddressesRequest mocks base method. +func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAddressesOutput) + return ret0, ret1 +} + +// DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest. +func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0) +} + +// DescribeAddressesWithContext mocks base method. +func (m *MockEC2API) DescribeAddressesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(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, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...) +} + +// DescribeAggregateIdFormat mocks base method. +func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0) + ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat. +func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0) } // DescribeAggregateIdFormatRequest mocks base method. @@ -12072,6 +12805,172 @@ func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsWithContext(arg0, arg1 inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsWithContext), varargs...) } +// DescribeNetworkInsightsAnalyses mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsAnalyses(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalyses", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInsightsAnalyses indicates an expected call of DescribeNetworkInsightsAnalyses. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalyses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalyses", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalyses), arg0) +} + +// DescribeNetworkInsightsAnalysesPages mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInsightsAnalysesPages indicates an expected call of DescribeNetworkInsightsAnalysesPages. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesPages), arg0, arg1) +} + +// DescribeNetworkInsightsAnalysesPagesWithContext mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsAnalysesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAnalysesOutput, 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, "DescribeNetworkInsightsAnalysesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInsightsAnalysesPagesWithContext indicates an expected call of DescribeNetworkInsightsAnalysesPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesPagesWithContext(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, "DescribeNetworkInsightsAnalysesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesPagesWithContext), varargs...) +} + +// DescribeNetworkInsightsAnalysesRequest mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAnalysesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAnalysesOutput) + return ret0, ret1 +} + +// DescribeNetworkInsightsAnalysesRequest indicates an expected call of DescribeNetworkInsightsAnalysesRequest. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesRequest), arg0) +} + +// DescribeNetworkInsightsAnalysesWithContext mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsAnalysesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInsightsAnalysesWithContext indicates an expected call of DescribeNetworkInsightsAnalysesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesWithContext(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, "DescribeNetworkInsightsAnalysesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesWithContext), varargs...) +} + +// DescribeNetworkInsightsPaths mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsPaths(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*ec2.DescribeNetworkInsightsPathsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsPaths", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInsightsPaths indicates an expected call of DescribeNetworkInsightsPaths. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPaths(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPaths", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPaths), arg0) +} + +// DescribeNetworkInsightsPathsPages mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsPathsPages(arg0 *ec2.DescribeNetworkInsightsPathsInput, arg1 func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInsightsPathsPages indicates an expected call of DescribeNetworkInsightsPathsPages. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsPages), arg0, arg1) +} + +// DescribeNetworkInsightsPathsPagesWithContext mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsPathsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 func(*ec2.DescribeNetworkInsightsPathsOutput, 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, "DescribeNetworkInsightsPathsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInsightsPathsPagesWithContext indicates an expected call of DescribeNetworkInsightsPathsPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsPagesWithContext(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, "DescribeNetworkInsightsPathsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsPagesWithContext), varargs...) +} + +// DescribeNetworkInsightsPathsRequest mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsPathsRequest(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*request.Request, *ec2.DescribeNetworkInsightsPathsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsPathsOutput) + return ret0, ret1 +} + +// DescribeNetworkInsightsPathsRequest indicates an expected call of DescribeNetworkInsightsPathsRequest. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsRequest), arg0) +} + +// DescribeNetworkInsightsPathsWithContext mocks base method. +func (m *MockEC2API) DescribeNetworkInsightsPathsWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsPathsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInsightsPathsWithContext indicates an expected call of DescribeNetworkInsightsPathsWithContext. +func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsWithContext(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, "DescribeNetworkInsightsPathsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsWithContext), varargs...) +} + // DescribeNetworkInterfaceAttribute mocks base method. func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { m.ctrl.T.Helper() @@ -12637,6 +13536,89 @@ func (mr *MockEC2APIMockRecorder) DescribeRegionsWithContext(arg0, arg1 interfac return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...) } +// DescribeReplaceRootVolumeTasks mocks base method. +func (m *MockEC2API) DescribeReplaceRootVolumeTasks(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReplaceRootVolumeTasks indicates an expected call of DescribeReplaceRootVolumeTasks. +func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasks), arg0) +} + +// DescribeReplaceRootVolumeTasksPages mocks base method. +func (m *MockEC2API) DescribeReplaceRootVolumeTasksPages(arg0 *ec2.DescribeReplaceRootVolumeTasksInput, arg1 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReplaceRootVolumeTasksPages indicates an expected call of DescribeReplaceRootVolumeTasksPages. +func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPages), arg0, arg1) +} + +// DescribeReplaceRootVolumeTasksPagesWithContext mocks base method. +func (m *MockEC2API) DescribeReplaceRootVolumeTasksPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 func(*ec2.DescribeReplaceRootVolumeTasksOutput, 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, "DescribeReplaceRootVolumeTasksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReplaceRootVolumeTasksPagesWithContext indicates an expected call of DescribeReplaceRootVolumeTasksPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPagesWithContext(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, "DescribeReplaceRootVolumeTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPagesWithContext), varargs...) +} + +// DescribeReplaceRootVolumeTasksRequest mocks base method. +func (m *MockEC2API) DescribeReplaceRootVolumeTasksRequest(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*request.Request, *ec2.DescribeReplaceRootVolumeTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeReplaceRootVolumeTasksOutput) + return ret0, ret1 +} + +// DescribeReplaceRootVolumeTasksRequest indicates an expected call of DescribeReplaceRootVolumeTasksRequest. +func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksRequest), arg0) +} + +// DescribeReplaceRootVolumeTasksWithContext mocks base method. +func (m *MockEC2API) DescribeReplaceRootVolumeTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 ...request.Option) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReplaceRootVolumeTasksWithContext indicates an expected call of DescribeReplaceRootVolumeTasksWithContext. +func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksWithContext(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, "DescribeReplaceRootVolumeTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksWithContext), varargs...) +} + // DescribeReservedInstances mocks base method. func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) { m.ctrl.T.Helper() @@ -13900,100 +14882,183 @@ func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsWithContext(arg0, a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsWithContext), varargs...) } -// DescribeSubnets mocks base method. -func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { +// DescribeStoreImageTasks mocks base method. +func (m *MockEC2API) DescribeStoreImageTasks(arg0 *ec2.DescribeStoreImageTasksInput) (*ec2.DescribeStoreImageTasksOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnets", arg0) - ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) + ret := m.ctrl.Call(m, "DescribeStoreImageTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeSubnets indicates an expected call of DescribeSubnets. -func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { +// DescribeStoreImageTasks indicates an expected call of DescribeStoreImageTasks. +func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasks), arg0) } -// DescribeSubnetsPages mocks base method. -func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error { +// DescribeStoreImageTasksPages mocks base method. +func (m *MockEC2API) DescribeStoreImageTasksPages(arg0 *ec2.DescribeStoreImageTasksInput, arg1 func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1) + ret := m.ctrl.Call(m, "DescribeStoreImageTasksPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -// DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages. -func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { +// DescribeStoreImageTasksPages indicates an expected call of DescribeStoreImageTasksPages. +func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksPages), arg0, arg1) } -// DescribeSubnetsPagesWithContext mocks base method. -func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, bool) bool, arg3 ...request.Option) error { +// DescribeStoreImageTasksPagesWithContext mocks base method. +func (m *MockEC2API) DescribeStoreImageTasksPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 func(*ec2.DescribeStoreImageTasksOutput, 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, "DescribeSubnetsPagesWithContext", varargs...) + ret := m.ctrl.Call(m, "DescribeStoreImageTasksPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } -// DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext. -func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { +// DescribeStoreImageTasksPagesWithContext indicates an expected call of DescribeStoreImageTasksPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksPagesWithContext(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, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksPagesWithContext), varargs...) } -// DescribeSubnetsRequest mocks base method. -func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) { +// DescribeStoreImageTasksRequest mocks base method. +func (m *MockEC2API) DescribeStoreImageTasksRequest(arg0 *ec2.DescribeStoreImageTasksInput) (*request.Request, *ec2.DescribeStoreImageTasksOutput) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0) + ret := m.ctrl.Call(m, "DescribeStoreImageTasksRequest", arg0) ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput) + ret1, _ := ret[1].(*ec2.DescribeStoreImageTasksOutput) return ret0, ret1 } -// DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest. -func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { +// DescribeStoreImageTasksRequest indicates an expected call of DescribeStoreImageTasksRequest. +func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksRequest), arg0) } -// DescribeSubnetsWithContext mocks base method. -func (m *MockEC2API) DescribeSubnetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) { +// DescribeStoreImageTasksWithContext mocks base method. +func (m *MockEC2API) DescribeStoreImageTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 ...request.Option) (*ec2.DescribeStoreImageTasksOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) + ret := m.ctrl.Call(m, "DescribeStoreImageTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext. -func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeStoreImageTasksWithContext indicates an expected call of DescribeStoreImageTasksWithContext. +func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksWithContext(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, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksWithContext), varargs...) } -// DescribeTags mocks base method. -func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) { +// DescribeSubnets mocks base method. +func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTags", arg0) - ret0, _ := ret[0].(*ec2.DescribeTagsOutput) + ret := m.ctrl.Call(m, "DescribeSubnets", arg0) + ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeTags indicates an expected call of DescribeTags. -func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { +// DescribeSubnets indicates an expected call of DescribeSubnets. +func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0) +} + +// DescribeSubnetsPages mocks base method. +func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages. +func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1) +} + +// DescribeSubnetsPagesWithContext mocks base method. +func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, 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, "DescribeSubnetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(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, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...) +} + +// DescribeSubnetsRequest mocks base method. +func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput) + return ret0, ret1 +} + +// DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest. +func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0) +} + +// DescribeSubnetsWithContext mocks base method. +func (m *MockEC2API) DescribeSubnetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext. +func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(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, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...) +} + +// DescribeTags mocks base method. +func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTags", arg0) + ret0, _ := ret[0].(*ec2.DescribeTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTags indicates an expected call of DescribeTags. +func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0) } @@ -14398,6 +15463,172 @@ func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsWithContext(a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...) } +// DescribeTransitGatewayConnectPeers mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectPeers(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeers", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayConnectPeers indicates an expected call of DescribeTransitGatewayConnectPeers. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeers", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeers), arg0) +} + +// DescribeTransitGatewayConnectPeersPages mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectPeersPages(arg0 *ec2.DescribeTransitGatewayConnectPeersInput, arg1 func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayConnectPeersPages indicates an expected call of DescribeTransitGatewayConnectPeersPages. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersPages), arg0, arg1) +} + +// DescribeTransitGatewayConnectPeersPagesWithContext mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectPeersPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 func(*ec2.DescribeTransitGatewayConnectPeersOutput, 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, "DescribeTransitGatewayConnectPeersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayConnectPeersPagesWithContext indicates an expected call of DescribeTransitGatewayConnectPeersPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersPagesWithContext(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, "DescribeTransitGatewayConnectPeersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersPagesWithContext), varargs...) +} + +// DescribeTransitGatewayConnectPeersRequest mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectPeersRequest(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*request.Request, *ec2.DescribeTransitGatewayConnectPeersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectPeersOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayConnectPeersRequest indicates an expected call of DescribeTransitGatewayConnectPeersRequest. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersRequest), arg0) +} + +// DescribeTransitGatewayConnectPeersWithContext mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectPeersWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayConnectPeersWithContext indicates an expected call of DescribeTransitGatewayConnectPeersWithContext. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersWithContext(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, "DescribeTransitGatewayConnectPeersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersWithContext), varargs...) +} + +// DescribeTransitGatewayConnects mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnects(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*ec2.DescribeTransitGatewayConnectsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnects", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayConnects indicates an expected call of DescribeTransitGatewayConnects. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnects(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnects", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnects), arg0) +} + +// DescribeTransitGatewayConnectsPages mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectsPages(arg0 *ec2.DescribeTransitGatewayConnectsInput, arg1 func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayConnectsPages indicates an expected call of DescribeTransitGatewayConnectsPages. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsPages), arg0, arg1) +} + +// DescribeTransitGatewayConnectsPagesWithContext mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 func(*ec2.DescribeTransitGatewayConnectsOutput, 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, "DescribeTransitGatewayConnectsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayConnectsPagesWithContext indicates an expected call of DescribeTransitGatewayConnectsPagesWithContext. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsPagesWithContext(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, "DescribeTransitGatewayConnectsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsPagesWithContext), varargs...) +} + +// DescribeTransitGatewayConnectsRequest mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectsRequest(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*request.Request, *ec2.DescribeTransitGatewayConnectsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectsOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayConnectsRequest indicates an expected call of DescribeTransitGatewayConnectsRequest. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsRequest), arg0) +} + +// DescribeTransitGatewayConnectsWithContext mocks base method. +func (m *MockEC2API) DescribeTransitGatewayConnectsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayConnectsWithContext indicates an expected call of DescribeTransitGatewayConnectsWithContext. +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsWithContext(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, "DescribeTransitGatewayConnectsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsWithContext), varargs...) +} + // DescribeTransitGatewayMulticastDomains mocks base method. func (m *MockEC2API) DescribeTransitGatewayMulticastDomains(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { m.ctrl.T.Helper() @@ -14813,6 +16044,56 @@ func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysWithContext(arg0, arg1 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysWithContext), varargs...) } +// DescribeTrunkInterfaceAssociations mocks base method. +func (m *MockEC2API) DescribeTrunkInterfaceAssociations(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociations", arg0) + ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrunkInterfaceAssociations indicates an expected call of DescribeTrunkInterfaceAssociations. +func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociations), arg0) +} + +// DescribeTrunkInterfaceAssociationsRequest mocks base method. +func (m *MockEC2API) DescribeTrunkInterfaceAssociationsRequest(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*request.Request, *ec2.DescribeTrunkInterfaceAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTrunkInterfaceAssociationsOutput) + return ret0, ret1 +} + +// DescribeTrunkInterfaceAssociationsRequest indicates an expected call of DescribeTrunkInterfaceAssociationsRequest. +func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsRequest), arg0) +} + +// DescribeTrunkInterfaceAssociationsWithContext mocks base method. +func (m *MockEC2API) DescribeTrunkInterfaceAssociationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 ...request.Option) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrunkInterfaceAssociationsWithContext indicates an expected call of DescribeTrunkInterfaceAssociationsWithContext. +func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsWithContext(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, "DescribeTrunkInterfaceAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsWithContext), varargs...) +} + // DescribeVolumeAttribute mocks base method. func (m *MockEC2API) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) { m.ctrl.T.Helper() @@ -16376,6 +17657,106 @@ func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresWithContext(arg0, a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresWithContext), varargs...) } +// DisableImageDeprecation mocks base method. +func (m *MockEC2API) DisableImageDeprecation(arg0 *ec2.DisableImageDeprecationInput) (*ec2.DisableImageDeprecationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableImageDeprecation", arg0) + ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableImageDeprecation indicates an expected call of DisableImageDeprecation. +func (mr *MockEC2APIMockRecorder) DisableImageDeprecation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecation), arg0) +} + +// DisableImageDeprecationRequest mocks base method. +func (m *MockEC2API) DisableImageDeprecationRequest(arg0 *ec2.DisableImageDeprecationInput) (*request.Request, *ec2.DisableImageDeprecationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableImageDeprecationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableImageDeprecationOutput) + return ret0, ret1 +} + +// DisableImageDeprecationRequest indicates an expected call of DisableImageDeprecationRequest. +func (mr *MockEC2APIMockRecorder) DisableImageDeprecationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationRequest), arg0) +} + +// DisableImageDeprecationWithContext mocks base method. +func (m *MockEC2API) DisableImageDeprecationWithContext(arg0 aws.Context, arg1 *ec2.DisableImageDeprecationInput, arg2 ...request.Option) (*ec2.DisableImageDeprecationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableImageDeprecationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableImageDeprecationWithContext indicates an expected call of DisableImageDeprecationWithContext. +func (mr *MockEC2APIMockRecorder) DisableImageDeprecationWithContext(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, "DisableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationWithContext), varargs...) +} + +// DisableSerialConsoleAccess mocks base method. +func (m *MockEC2API) DisableSerialConsoleAccess(arg0 *ec2.DisableSerialConsoleAccessInput) (*ec2.DisableSerialConsoleAccessOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableSerialConsoleAccess", arg0) + ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableSerialConsoleAccess indicates an expected call of DisableSerialConsoleAccess. +func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccess(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccess), arg0) +} + +// DisableSerialConsoleAccessRequest mocks base method. +func (m *MockEC2API) DisableSerialConsoleAccessRequest(arg0 *ec2.DisableSerialConsoleAccessInput) (*request.Request, *ec2.DisableSerialConsoleAccessOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableSerialConsoleAccessRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableSerialConsoleAccessOutput) + return ret0, ret1 +} + +// DisableSerialConsoleAccessRequest indicates an expected call of DisableSerialConsoleAccessRequest. +func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessRequest), arg0) +} + +// DisableSerialConsoleAccessWithContext mocks base method. +func (m *MockEC2API) DisableSerialConsoleAccessWithContext(arg0 aws.Context, arg1 *ec2.DisableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.DisableSerialConsoleAccessOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableSerialConsoleAccessWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableSerialConsoleAccessWithContext indicates an expected call of DisableSerialConsoleAccessWithContext. +func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessWithContext(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, "DisableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessWithContext), varargs...) +} + // DisableTransitGatewayRouteTablePropagation mocks base method. func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { m.ctrl.T.Helper() @@ -16676,6 +18057,56 @@ func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkWithContext( return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...) } +// DisassociateEnclaveCertificateIamRole mocks base method. +func (m *MockEC2API) DisassociateEnclaveCertificateIamRole(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRole", arg0) + ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateEnclaveCertificateIamRole indicates an expected call of DisassociateEnclaveCertificateIamRole. +func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRole), arg0) +} + +// DisassociateEnclaveCertificateIamRoleRequest mocks base method. +func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleRequest(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.DisassociateEnclaveCertificateIamRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateEnclaveCertificateIamRoleOutput) + return ret0, ret1 +} + +// DisassociateEnclaveCertificateIamRoleRequest indicates an expected call of DisassociateEnclaveCertificateIamRoleRequest. +func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRoleRequest), arg0) +} + +// DisassociateEnclaveCertificateIamRoleWithContext mocks base method. +func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleWithContext(arg0 aws.Context, arg1 *ec2.DisassociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateEnclaveCertificateIamRoleWithContext indicates an expected call of DisassociateEnclaveCertificateIamRoleWithContext. +func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRoleWithContext(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, "DisassociateEnclaveCertificateIamRoleWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRoleWithContext), varargs...) +} + // DisassociateIamInstanceProfile mocks base method. func (m *MockEC2API) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) { m.ctrl.T.Helper() @@ -16926,6 +18357,56 @@ func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableWithContex return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...) } +// DisassociateTrunkInterface mocks base method. +func (m *MockEC2API) DisassociateTrunkInterface(arg0 *ec2.DisassociateTrunkInterfaceInput) (*ec2.DisassociateTrunkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTrunkInterface", arg0) + ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTrunkInterface indicates an expected call of DisassociateTrunkInterface. +func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterface), arg0) +} + +// DisassociateTrunkInterfaceRequest mocks base method. +func (m *MockEC2API) DisassociateTrunkInterfaceRequest(arg0 *ec2.DisassociateTrunkInterfaceInput) (*request.Request, *ec2.DisassociateTrunkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateTrunkInterfaceOutput) + return ret0, ret1 +} + +// DisassociateTrunkInterfaceRequest indicates an expected call of DisassociateTrunkInterfaceRequest. +func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterfaceRequest), arg0) +} + +// DisassociateTrunkInterfaceWithContext mocks base method. +func (m *MockEC2API) DisassociateTrunkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.DisassociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.DisassociateTrunkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTrunkInterfaceWithContext indicates an expected call of DisassociateTrunkInterfaceWithContext. +func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterfaceWithContext(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, "DisassociateTrunkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterfaceWithContext), varargs...) +} + // DisassociateVpcCidrBlock mocks base method. func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) { m.ctrl.T.Helper() @@ -16963,117 +18444,217 @@ func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 aws.Context, arg1 for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) + ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateVpcCidrBlockWithContext indicates an expected call of DisassociateVpcCidrBlockWithContext. +func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(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, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...) +} + +// EnableEbsEncryptionByDefault mocks base method. +func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0) + ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault. +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0) +} + +// EnableEbsEncryptionByDefaultRequest mocks base method. +func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest. +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0) +} + +// EnableEbsEncryptionByDefaultWithContext mocks base method. +func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext. +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(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, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) +} + +// EnableFastSnapshotRestores mocks base method. +func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0) + ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores. +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0) +} + +// EnableFastSnapshotRestoresRequest mocks base method. +func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput) + return ret0, ret1 +} + +// EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest. +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0) +} + +// EnableFastSnapshotRestoresWithContext mocks base method. +func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 aws.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DisassociateVpcCidrBlockWithContext indicates an expected call of DisassociateVpcCidrBlockWithContext. -func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext. +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(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, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...) } -// EnableEbsEncryptionByDefault mocks base method. -func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { +// EnableImageDeprecation mocks base method. +func (m *MockEC2API) EnableImageDeprecation(arg0 *ec2.EnableImageDeprecationInput) (*ec2.EnableImageDeprecationOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0) - ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret := m.ctrl.Call(m, "EnableImageDeprecation", arg0) + ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault. -func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { +// EnableImageDeprecation indicates an expected call of EnableImageDeprecation. +func (mr *MockEC2APIMockRecorder) EnableImageDeprecation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecation), arg0) } -// EnableEbsEncryptionByDefaultRequest mocks base method. -func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) { +// EnableImageDeprecationRequest mocks base method. +func (m *MockEC2API) EnableImageDeprecationRequest(arg0 *ec2.EnableImageDeprecationInput) (*request.Request, *ec2.EnableImageDeprecationOutput) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0) + ret := m.ctrl.Call(m, "EnableImageDeprecationRequest", arg0) ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(*ec2.EnableImageDeprecationOutput) return ret0, ret1 } -// EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest. -func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { +// EnableImageDeprecationRequest indicates an expected call of EnableImageDeprecationRequest. +func (mr *MockEC2APIMockRecorder) EnableImageDeprecationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationRequest), arg0) } -// EnableEbsEncryptionByDefaultWithContext mocks base method. -func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { +// EnableImageDeprecationWithContext mocks base method. +func (m *MockEC2API) EnableImageDeprecationWithContext(arg0 aws.Context, arg1 *ec2.EnableImageDeprecationInput, arg2 ...request.Option) (*ec2.EnableImageDeprecationOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret := m.ctrl.Call(m, "EnableImageDeprecationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext. -func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// EnableImageDeprecationWithContext indicates an expected call of EnableImageDeprecationWithContext. +func (mr *MockEC2APIMockRecorder) EnableImageDeprecationWithContext(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, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationWithContext), varargs...) } -// EnableFastSnapshotRestores mocks base method. -func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) { +// EnableSerialConsoleAccess mocks base method. +func (m *MockEC2API) EnableSerialConsoleAccess(arg0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0) - ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) + ret := m.ctrl.Call(m, "EnableSerialConsoleAccess", arg0) + ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores. -func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call { +// EnableSerialConsoleAccess indicates an expected call of EnableSerialConsoleAccess. +func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccess(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccess), arg0) } -// EnableFastSnapshotRestoresRequest mocks base method. -func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) { +// EnableSerialConsoleAccessRequest mocks base method. +func (m *MockEC2API) EnableSerialConsoleAccessRequest(arg0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0) + ret := m.ctrl.Call(m, "EnableSerialConsoleAccessRequest", arg0) ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(*ec2.EnableSerialConsoleAccessOutput) return ret0, ret1 } -// EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest. -func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { +// EnableSerialConsoleAccessRequest indicates an expected call of EnableSerialConsoleAccessRequest. +func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessRequest), arg0) } -// EnableFastSnapshotRestoresWithContext mocks base method. -func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 aws.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) { +// EnableSerialConsoleAccessWithContext mocks base method. +func (m *MockEC2API) EnableSerialConsoleAccessWithContext(arg0 aws.Context, arg1 *ec2.EnableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.EnableSerialConsoleAccessOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) + ret := m.ctrl.Call(m, "EnableSerialConsoleAccessWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext. -func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// EnableSerialConsoleAccessWithContext indicates an expected call of EnableSerialConsoleAccessWithContext. +func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessWithContext(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, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessWithContext), varargs...) } // EnableTransitGatewayRouteTablePropagation mocks base method. @@ -17526,6 +19107,56 @@ func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesWithContext(arg0, ar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...) } +// GetAssociatedEnclaveCertificateIamRoles mocks base method. +func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRoles(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRoles", arg0) + ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssociatedEnclaveCertificateIamRoles indicates an expected call of GetAssociatedEnclaveCertificateIamRoles. +func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRoles(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRoles", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRoles), arg0) +} + +// GetAssociatedEnclaveCertificateIamRolesRequest mocks base method. +func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*request.Request, *ec2.GetAssociatedEnclaveCertificateIamRolesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput) + return ret0, ret1 +} + +// GetAssociatedEnclaveCertificateIamRolesRequest indicates an expected call of GetAssociatedEnclaveCertificateIamRolesRequest. +func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRolesRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRolesRequest), arg0) +} + +// GetAssociatedEnclaveCertificateIamRolesWithContext mocks base method. +func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesWithContext(arg0 aws.Context, arg1 *ec2.GetAssociatedEnclaveCertificateIamRolesInput, arg2 ...request.Option) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssociatedEnclaveCertificateIamRolesWithContext indicates an expected call of GetAssociatedEnclaveCertificateIamRolesWithContext. +func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRolesWithContext(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, "GetAssociatedEnclaveCertificateIamRolesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRolesWithContext), varargs...) +} + // GetAssociatedIpv6PoolCidrs mocks base method. func (m *MockEC2API) GetAssociatedIpv6PoolCidrs(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) { m.ctrl.T.Helper() @@ -17959,6 +19590,56 @@ func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultWithContext(arg0, arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...) } +// GetFlowLogsIntegrationTemplate mocks base method. +func (m *MockEC2API) GetFlowLogsIntegrationTemplate(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplate", arg0) + ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFlowLogsIntegrationTemplate indicates an expected call of GetFlowLogsIntegrationTemplate. +func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplate", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplate), arg0) +} + +// GetFlowLogsIntegrationTemplateRequest mocks base method. +func (m *MockEC2API) GetFlowLogsIntegrationTemplateRequest(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*request.Request, *ec2.GetFlowLogsIntegrationTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetFlowLogsIntegrationTemplateOutput) + return ret0, ret1 +} + +// GetFlowLogsIntegrationTemplateRequest indicates an expected call of GetFlowLogsIntegrationTemplateRequest. +func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateRequest), arg0) +} + +// GetFlowLogsIntegrationTemplateWithContext mocks base method. +func (m *MockEC2API) GetFlowLogsIntegrationTemplateWithContext(arg0 aws.Context, arg1 *ec2.GetFlowLogsIntegrationTemplateInput, arg2 ...request.Option) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFlowLogsIntegrationTemplateWithContext indicates an expected call of GetFlowLogsIntegrationTemplateWithContext. +func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateWithContext(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, "GetFlowLogsIntegrationTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateWithContext), varargs...) +} + // GetGroupsForCapacityReservation mocks base method. func (m *MockEC2API) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) { m.ctrl.T.Helper() @@ -18408,6 +20089,56 @@ func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteWithContext(a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...) } +// GetSerialConsoleAccessStatus mocks base method. +func (m *MockEC2API) GetSerialConsoleAccessStatus(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*ec2.GetSerialConsoleAccessStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatus", arg0) + ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSerialConsoleAccessStatus indicates an expected call of GetSerialConsoleAccessStatus. +func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatus", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatus), arg0) +} + +// GetSerialConsoleAccessStatusRequest mocks base method. +func (m *MockEC2API) GetSerialConsoleAccessStatusRequest(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*request.Request, *ec2.GetSerialConsoleAccessStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetSerialConsoleAccessStatusOutput) + return ret0, ret1 +} + +// GetSerialConsoleAccessStatusRequest indicates an expected call of GetSerialConsoleAccessStatusRequest. +func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusRequest), arg0) +} + +// GetSerialConsoleAccessStatusWithContext mocks base method. +func (m *MockEC2API) GetSerialConsoleAccessStatusWithContext(arg0 aws.Context, arg1 *ec2.GetSerialConsoleAccessStatusInput, arg2 ...request.Option) (*ec2.GetSerialConsoleAccessStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSerialConsoleAccessStatusWithContext indicates an expected call of GetSerialConsoleAccessStatusWithContext. +func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusWithContext(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, "GetSerialConsoleAccessStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusWithContext), varargs...) +} + // GetTransitGatewayAttachmentPropagations mocks base method. func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { m.ctrl.T.Helper() @@ -19123,6 +20854,56 @@ func (mr *MockEC2APIMockRecorder) ImportVolumeWithContext(arg0, arg1 interface{} return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeWithContext), varargs...) } +// ModifyAddressAttribute mocks base method. +func (m *MockEC2API) ModifyAddressAttribute(arg0 *ec2.ModifyAddressAttributeInput) (*ec2.ModifyAddressAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyAddressAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyAddressAttribute indicates an expected call of ModifyAddressAttribute. +func (mr *MockEC2APIMockRecorder) ModifyAddressAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttribute), arg0) +} + +// ModifyAddressAttributeRequest mocks base method. +func (m *MockEC2API) ModifyAddressAttributeRequest(arg0 *ec2.ModifyAddressAttributeInput) (*request.Request, *ec2.ModifyAddressAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyAddressAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyAddressAttributeOutput) + return ret0, ret1 +} + +// ModifyAddressAttributeRequest indicates an expected call of ModifyAddressAttributeRequest. +func (mr *MockEC2APIMockRecorder) ModifyAddressAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttributeRequest), arg0) +} + +// ModifyAddressAttributeWithContext mocks base method. +func (m *MockEC2API) ModifyAddressAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyAddressAttributeInput, arg2 ...request.Option) (*ec2.ModifyAddressAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyAddressAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyAddressAttributeWithContext indicates an expected call of ModifyAddressAttributeWithContext. +func (mr *MockEC2APIMockRecorder) ModifyAddressAttributeWithContext(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, "ModifyAddressAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttributeWithContext), varargs...) +} + // ModifyAvailabilityZoneGroup mocks base method. func (m *MockEC2API) ModifyAvailabilityZoneGroup(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) { m.ctrl.T.Helper() @@ -21823,6 +23604,56 @@ func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesWit return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) } +// RejectTransitGatewayMulticastDomainAssociations mocks base method. +func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociations(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociations", arg0) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayMulticastDomainAssociations indicates an expected call of RejectTransitGatewayMulticastDomainAssociations. +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociations), arg0) +} + +// RejectTransitGatewayMulticastDomainAssociationsRequest mocks base method. +func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) + return ret0, ret1 +} + +// RejectTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of RejectTransitGatewayMulticastDomainAssociationsRequest. +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociationsRequest), arg0) +} + +// RejectTransitGatewayMulticastDomainAssociationsWithContext mocks base method. +func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsWithContext(arg0 aws.Context, arg1 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of RejectTransitGatewayMulticastDomainAssociationsWithContext. +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociationsWithContext(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, "RejectTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociationsWithContext), varargs...) +} + // RejectTransitGatewayPeeringAttachment mocks base method. func (m *MockEC2API) RejectTransitGatewayPeeringAttachment(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) { m.ctrl.T.Helper() @@ -22573,6 +24404,56 @@ func (mr *MockEC2APIMockRecorder) RequestSpotInstancesWithContext(arg0, arg1 int return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesWithContext), varargs...) } +// ResetAddressAttribute mocks base method. +func (m *MockEC2API) ResetAddressAttribute(arg0 *ec2.ResetAddressAttributeInput) (*ec2.ResetAddressAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetAddressAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetAddressAttribute indicates an expected call of ResetAddressAttribute. +func (mr *MockEC2APIMockRecorder) ResetAddressAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttribute), arg0) +} + +// ResetAddressAttributeRequest mocks base method. +func (m *MockEC2API) ResetAddressAttributeRequest(arg0 *ec2.ResetAddressAttributeInput) (*request.Request, *ec2.ResetAddressAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetAddressAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetAddressAttributeOutput) + return ret0, ret1 +} + +// ResetAddressAttributeRequest indicates an expected call of ResetAddressAttributeRequest. +func (mr *MockEC2APIMockRecorder) ResetAddressAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttributeRequest), arg0) +} + +// ResetAddressAttributeWithContext mocks base method. +func (m *MockEC2API) ResetAddressAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetAddressAttributeInput, arg2 ...request.Option) (*ec2.ResetAddressAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetAddressAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetAddressAttributeWithContext indicates an expected call of ResetAddressAttributeWithContext. +func (mr *MockEC2APIMockRecorder) ResetAddressAttributeWithContext(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, "ResetAddressAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttributeWithContext), varargs...) +} + // ResetEbsDefaultKmsKeyId mocks base method. func (m *MockEC2API) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { m.ctrl.T.Helper() @@ -23539,6 +25420,56 @@ func (mr *MockEC2APIMockRecorder) StartInstancesWithContext(arg0, arg1 interface return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StartInstancesWithContext), varargs...) } +// StartNetworkInsightsAnalysis mocks base method. +func (m *MockEC2API) StartNetworkInsightsAnalysis(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*ec2.StartNetworkInsightsAnalysisOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysis", arg0) + ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartNetworkInsightsAnalysis indicates an expected call of StartNetworkInsightsAnalysis. +func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysis), arg0) +} + +// StartNetworkInsightsAnalysisRequest mocks base method. +func (m *MockEC2API) StartNetworkInsightsAnalysisRequest(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAnalysisOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.StartNetworkInsightsAnalysisOutput) + return ret0, ret1 +} + +// StartNetworkInsightsAnalysisRequest indicates an expected call of StartNetworkInsightsAnalysisRequest. +func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysisRequest), arg0) +} + +// StartNetworkInsightsAnalysisWithContext mocks base method. +func (m *MockEC2API) StartNetworkInsightsAnalysisWithContext(arg0 aws.Context, arg1 *ec2.StartNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAnalysisOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisWithContext", varargs...) + ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartNetworkInsightsAnalysisWithContext indicates an expected call of StartNetworkInsightsAnalysisWithContext. +func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysisWithContext(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, "StartNetworkInsightsAnalysisWithContext", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysisWithContext), varargs...) +} + // StartVpcEndpointServicePrivateDnsVerification mocks base method. func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerification(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) { m.ctrl.T.Helper() diff --git a/go.mod b/go.mod index 3618b128..3422d053 100644 --- a/go.mod +++ b/go.mod @@ -3,11 +3,11 @@ module github.com/gruntwork-io/cloud-nuke go 1.13 require ( - github.com/aws/aws-sdk-go v1.34.27 + github.com/aws/aws-sdk-go v1.38.68 github.com/fatih/color v1.9.0 - github.com/golang/mock v1.4.0 + github.com/golang/mock v1.6.0 github.com/gruntwork-io/go-commons v0.8.2 - github.com/gruntwork-io/terratest v0.32.9 + github.com/gruntwork-io/terratest v0.36.3 github.com/hashicorp/go-multierror v1.1.0 github.com/pquerna/otp v1.3.0 github.com/sirupsen/logrus v1.6.0 diff --git a/go.sum b/go.sum index 2746f931..6aa9cb9b 100644 --- a/go.sum +++ b/go.sum @@ -66,8 +66,10 @@ github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQ github.com/aws/aws-sdk-go v1.16.26/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.27.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.30.0/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0= -github.com/aws/aws-sdk-go v1.34.27 h1:qBqccUrlz43Zermh0U1O502bHYZsgMlBm+LUVabzBPA= github.com/aws/aws-sdk-go v1.34.27/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0= +github.com/aws/aws-sdk-go v1.38.28/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= +github.com/aws/aws-sdk-go v1.38.68 h1:aOG8geU4SohNp659eKBHRBgbqSrZ6jNZlfimIuJAwL8= +github.com/aws/aws-sdk-go v1.38.68/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= @@ -179,8 +181,8 @@ github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4er github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.0 h1:Rd1kQnQu0Hq3qvJppYSG0HtP+f5LPPUiDswTLiEegLg= -github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -229,14 +231,15 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= +github.com/gruntwork-io/go-commons v0.8.0/go.mod h1:gtp0yTtIBExIZp7vyIV9I0XQkVwiQZze678hvDXof78= github.com/gruntwork-io/go-commons v0.8.2 h1:2jrQH6ou6GxShXpNmxhVuVktp5E2so115nSESbbDOj0= github.com/gruntwork-io/go-commons v0.8.2/go.mod h1:aH1kYhkEgb7+RRMDVVKFXBBX0KfECzEhp1UYmU12oO4= -github.com/gruntwork-io/gruntwork-cli v0.7.0 h1:YgSAmfCj9c61H+zuvHwKfYUwlMhu5arnQQLM4RH+CYs= github.com/gruntwork-io/gruntwork-cli v0.7.0/go.mod h1:jp6Z7NcLF2avpY8v71fBx6hds9eOFPELSuD/VPv7w00= github.com/gruntwork-io/kubergrunt v0.6.10/go.mod h1:AjSwJPP107t8pihDgJCWCG/RG92Q1oiRXL/OdR6OiaQ= github.com/gruntwork-io/terratest v0.30.0/go.mod h1:7dNmTD2zDKUEVqfmvcUU5c9mZi+986mcXNzhzqPYPg8= -github.com/gruntwork-io/terratest v0.32.9 h1:ciWWJxISk06LAYImn6h1Vvir8hUz13VtwT2//fYCDcA= github.com/gruntwork-io/terratest v0.32.9/go.mod h1:FckR+7ks472IJfSKUPfPvnJfSxV1LKGWGMJ9m/LHegE= +github.com/gruntwork-io/terratest v0.36.3 h1:R/wCo6RSPJMQBt573XQy07Ylp7J7BX3SgCB+bi06QfU= +github.com/gruntwork-io/terratest v0.36.3/go.mod h1:GIVJGBV1WIv1vxIG31Ycy0CuHYfXuvvkilNQuC9Wi+o= github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g4TbElacI= @@ -246,6 +249,7 @@ github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/hcl/v2 v2.8.2/go.mod h1:bQTN5mpo+jewjJgh8jr0JUguIi7qPHUF6yIfAEN3jqY= +github.com/hashicorp/terraform-json v0.9.0/go.mod h1:3defM4kkMfttwiE7VakJDwCd4R+umhSQnvJwORXbprE= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= @@ -253,8 +257,11 @@ github.com/imdario/mergo v0.3.7/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJ github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a/go.mod h1:yL958EeXv8Ylng6IfnvG4oflryUi3vgA3xPs9hmII1s= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= -github.com/jmespath/go-jmespath v0.3.0 h1:OS12ieG61fsCg5+qLJ+SsW9NicxNkg3b25OyT2yCeUc= github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/joefitzgerald/rainbow-reporter v0.1.0/go.mod h1:481CNgqmVHQZzdIbN52CupLJyoVwB10FQ/IQlF1pdL8= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= @@ -415,7 +422,10 @@ github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6Ac github.com/vmware/govmomi v0.20.3/go.mod h1:URlwyTFZX72RmxtxuaFL2Uj3fD1JTvZdx59bHWk6aFU= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/zclconf/go-cty v1.2.0/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8= +github.com/zclconf/go-cty v1.2.1/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= @@ -464,6 +474,8 @@ golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCc golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -491,8 +503,11 @@ golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -504,6 +519,8 @@ golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -537,12 +554,16 @@ golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221 h1:/ZHdbVpdR/jk3g30/d4yUL0JU9kksj8+F/bnQUVLGDM= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= @@ -575,14 +596,18 @@ golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191205215504-7b8c8591a921/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200113040837-eac381796e91/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20201110201400-7099162a900a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.0.0-20190331200053-3d26580ed485/go.mod h1:2ltnJ7xHfj0zHS40VVPYEAAMTa3ZGguvHGBSJeRWqE0= gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= gonum.org/v1/netlib v0.0.0-20190331212654-76723241ea4e/go.mod h1:kS+toOQn6AQKjmKJ7gzohV1XkqsFehRA2FbsbkopSuQ= @@ -698,8 +723,6 @@ modernc.org/mathutil v1.0.0/go.mod h1:wU0vUrJsVWBZ4P6e7xtFJEhFSNsfRLJ8H458uRjg03 modernc.org/strutil v1.0.0/go.mod h1:lstksw84oURvj9y3tn8lGvRxyRC1S2+g5uuIzNfIOBs= modernc.org/xc v1.0.0/go.mod h1:mRNCo0bvLjGhHO9WsyuKVU4q0ceiDDDoEeWDJHrNx8I= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/aws-iam-authenticator v0.5.1/go.mod h1:yPDLi58MDx1UtCrRMOykLm1IyKKPGHgcGCafcbn2s3E= sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI= sigs.k8s.io/structured-merge-diff v1.0.1-0.20191108220359-b1b620dd3f06/go.mod h1:/ULNhyfzRopfcjskuui0cTITekDduZ7ycKN3oUT9R18= From a55dfa9fc362fd79bee9cb76556cb3ba44311b18 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Fri, 25 Jun 2021 15:45:29 -0500 Subject: [PATCH 2/8] Run secrets manager nuke in parallel --- aws/secrets_manager_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/aws/secrets_manager_test.go b/aws/secrets_manager_test.go index 09b6e232..65a88a25 100644 --- a/aws/secrets_manager_test.go +++ b/aws/secrets_manager_test.go @@ -67,6 +67,8 @@ func TestTimeFilterExclusionNewlyCreatedSecret(t *testing.T) { } func TestNukeSecretOne(t *testing.T) { + t.Parallel() + region, err := getRandomRegion() require.NoError(t, err) @@ -89,6 +91,8 @@ func TestNukeSecretOne(t *testing.T) { } func TestNukeSecretMoreThanOne(t *testing.T) { + t.Parallel() + region, err := getRandomRegion() require.NoError(t, err) From 1d8840c64e0a19db6c435721ec6cc706ad95c3fe Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Fri, 25 Jun 2021 15:52:15 -0500 Subject: [PATCH 3/8] Add ability to nuke NAT gateways --- README.md | 2 + aws/aws.go | 15 ++++ aws/nat_gateway.go | 141 +++++++++++++++++++++++++++++++++++ aws/nat_gateway_test.go | 154 +++++++++++++++++++++++++++++++++++++++ aws/nat_gateway_types.go | 38 ++++++++++ 5 files changed, 350 insertions(+) create mode 100644 aws/nat_gateway.go create mode 100644 aws/nat_gateway_test.go create mode 100644 aws/nat_gateway_types.go diff --git a/README.md b/README.md index 186aca2c..c33fe70e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ The currently supported functionality includes: - Deleting all S3 buckets in an AWS account - except for buckets tagged with Key=cloud-nuke-excluded Value=true - Deleting all default VPCs in an AWS account - Deleting all IAM users in an AWS account +- Deleting all Secrets Manager Secrets in an AWS account +- Deleting all NAT Gateways in an AWS account - Revoking the default rules in the un-deletable default security group of a VPC ### BEWARE! diff --git a/aws/aws.go b/aws/aws.go index 2a11917a..07c45926 100644 --- a/aws/aws.go +++ b/aws/aws.go @@ -336,6 +336,20 @@ func GetAllResources(targetRegions []string, excludeAfter time.Time, resourceTyp } // End TransitGateway + // NATGateway + natGateways := NatGateways{} + if IsNukeable(natGateways.ResourceName(), resourceTypes) { + ngwIDs, err := getAllNatGateways(session, excludeAfter) + if err != nil { + return nil, errors.WithStackTrace(err) + } + if len(ngwIDs) > 0 { + natGateways.NatGatewayIDs = awsgo.StringValueSlice(ngwIDs) + resourcesInRegion.Resources = append(resourcesInRegion.Resources, natGateways) + } + } + // End NATGateway + // EC2 Instances ec2Instances := EC2Instances{} if IsNukeable(ec2Instances.ResourceName(), resourceTypes) { @@ -627,6 +641,7 @@ func ListResourceTypes() []string { S3Buckets{}.ResourceName(), IAMUsers{}.ResourceName(), SecretsManagerSecrets{}.ResourceName(), + NatGateways{}.ResourceName(), } sort.Strings(resourceTypes) return resourceTypes diff --git a/aws/nat_gateway.go b/aws/nat_gateway.go new file mode 100644 index 00000000..8d3d12c2 --- /dev/null +++ b/aws/nat_gateway.go @@ -0,0 +1,141 @@ +package aws + +import ( + "fmt" + "sync" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/ec2" + "github.com/gruntwork-io/go-commons/errors" + "github.com/gruntwork-io/go-commons/retry" + multierror "github.com/hashicorp/go-multierror" + + "github.com/gruntwork-io/cloud-nuke/logging" +) + +func getAllNatGateways(session *session.Session, excludeAfter time.Time) ([]*string, error) { + svc := ec2.New(session) + + allNatGateways := []*string{} + input := &ec2.DescribeNatGatewaysInput{} + err := svc.DescribeNatGatewaysPages( + input, + func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool { + for _, ngw := range page.NatGateways { + if shouldIncludeNatGateway(ngw, excludeAfter) { + allNatGateways = append(allNatGateways, ngw.NatGatewayId) + } + } + return !lastPage + }, + ) + return allNatGateways, errors.WithStackTrace(err) +} + +func shouldIncludeNatGateway(ngw *ec2.NatGateway, excludeAfter time.Time) bool { + if ngw == nil { + return false + } + + if ngw.CreateTime != nil && excludeAfter.Before(*ngw.CreateTime) { + return false + } + return true +} + +func nukeAllNatGateways(session *session.Session, identifiers []*string) error { + region := aws.StringValue(session.Config.Region) + + svc := ec2.New(session) + + if len(identifiers) == 0 { + logging.Logger.Infof("No Nat Gateways to nuke in region %s", region) + return nil + } + + // There is no bulk delete nat gateway API, so we delete the batch of nat gateways concurrently using go routines. + logging.Logger.Infof("Deleting Nat Gateways in region %s", region) + wg := new(sync.WaitGroup) + wg.Add(len(identifiers)) + errChans := make([]chan error, len(identifiers)) + for i, ngwID := range identifiers { + errChans[i] = make(chan error, 1) + go deleteNatGatewayAsync(wg, errChans[i], svc, ngwID) + } + wg.Wait() + + // Collect all the errors from the async delete calls into a single error struct. + var allErrs *multierror.Error + for _, errChan := range errChans { + if err := <-errChan; err != nil { + allErrs = multierror.Append(allErrs, err) + logging.Logger.Errorf("[Failed] %s", err) + } + } + finalErr := allErrs.ErrorOrNil() + if finalErr != nil { + return errors.WithStackTrace(finalErr) + } + + // Now wait until the NAT gateways are deleted + err := retry.DoWithRetry( + logging.Logger, + "Waiting for all NAT gateways to be deleted.", + // Wait a maximum of 5 minutes: 10 seconds in between, up to 30 times + 30, 10*time.Second, + func() error { + areDeleted, err := areAllNatGatewaysDeleted(svc, identifiers) + if err != nil { + return errors.WithStackTrace(retry.FatalError{Underlying: err}) + } + if areDeleted { + return nil + } + return fmt.Errorf("Not all NAT gateways deleted.") + }, + ) + if err != nil { + return errors.WithStackTrace(err) + } + for _, ngwID := range identifiers { + logging.Logger.Infof("[OK] NAT Gateway %s was deleted in %s", aws.StringValue(ngwID), region) + } + return nil +} + +// areAllNatGatewaysDeleted returns true if all the requested NAT gateways have been deleted. This is determined by +// querying for the statuses of all the NAT gateways, and checking if AWS knows about them (if not, the NAT gateway was +// deleted and rolled off AWS DB) or if the status was updated to deleted. +func areAllNatGatewaysDeleted(svc *ec2.EC2, identifiers []*string) (bool, error) { + // NOTE: we don't need to do pagination here, because the pagination is handled by the caller to this function. + resp, err := svc.DescribeNatGateways(&ec2.DescribeNatGatewaysInput{NatGatewayIds: identifiers}) + if err != nil { + return false, err + } + if len(resp.NatGateways) == 0 { + return true, nil + } + for _, ngw := range resp.NatGateways { + if ngw == nil { + continue + } + + if aws.StringValue(ngw.State) != ec2.NatGatewayStateDeleted { + return false, nil + } + } + // At this point, all the NAT gateways are either nil, or in deleted state. + return true, nil +} + +// deleteNatGatewaysAsync deletes the provided NAT Gateway asynchronously in a goroutine, using wait groups for +// concurrency control and a return channel for errors. +func deleteNatGatewayAsync(wg *sync.WaitGroup, errChan chan error, svc *ec2.EC2, ngwID *string) { + defer wg.Done() + + input := &ec2.DeleteNatGatewayInput{NatGatewayId: ngwID} + _, err := svc.DeleteNatGateway(input) + errChan <- err +} diff --git a/aws/nat_gateway_test.go b/aws/nat_gateway_test.go new file mode 100644 index 00000000..1695cbc6 --- /dev/null +++ b/aws/nat_gateway_test.go @@ -0,0 +1,154 @@ +package aws + +import ( + "testing" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/ec2" + terraws "github.com/gruntwork-io/terratest/modules/aws" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestListNatGateways(t *testing.T) { + t.Parallel() + + region, err := getRandomRegion() + require.NoError(t, err) + + session, err := session.NewSession(&aws.Config{Region: aws.String(region)}) + require.NoError(t, err) + svc := ec2.New(session) + + ngwID := createNatGateway(t, svc, region) + defer deleteNatGateway(t, svc, ngwID, true) + + natGatewayIDs, err := getAllNatGateways(session, time.Now()) + require.NoError(t, err) + assert.Contains(t, aws.StringValueSlice(natGatewayIDs), aws.StringValue(ngwID)) +} + +func TestTimeFilterExclusionNewlyCreatedNatGateway(t *testing.T) { + t.Parallel() + + region, err := getRandomRegion() + require.NoError(t, err) + + session, err := session.NewSession(&aws.Config{Region: aws.String(region)}) + require.NoError(t, err) + svc := ec2.New(session) + + // Creates a NGW + ngwID := createNatGateway(t, svc, region) + defer deleteNatGateway(t, svc, ngwID, true) + + // Assert NGW is picked up without filters + natGatewayIDsNewer, err := getAllNatGateways(session, time.Now()) + require.NoError(t, err) + assert.Contains(t, aws.StringValueSlice(natGatewayIDsNewer), aws.StringValue(ngwID)) + + // Assert user doesn't appear when we look at users older than 1 Hour + olderThan := time.Now().Add(-1 * time.Hour) + natGatewayIDsOlder, err := getAllNatGateways(session, olderThan) + require.NoError(t, err) + assert.NotContains(t, aws.StringValueSlice(natGatewayIDsOlder), aws.StringValue(ngwID)) +} + +func TestNukeNatGatewayOne(t *testing.T) { + t.Parallel() + + region, err := getRandomRegion() + require.NoError(t, err) + + session, err := session.NewSession(&aws.Config{Region: aws.String(region)}) + require.NoError(t, err) + svc := ec2.New(session) + + // We ignore errors in the delete call here, because it is intended to be a stop gap in case there is a bug in nuke. + ngwID := createNatGateway(t, svc, region) + defer deleteNatGateway(t, svc, ngwID, false) + identifiers := []*string{ngwID} + + require.NoError( + t, + nukeAllNatGateways(session, identifiers), + ) + + // Make sure the NAT gateway is deleted. + assertNatGatewaysDeleted(t, svc, identifiers) +} + +func TestNukeNatGatewayMoreThanOne(t *testing.T) { + t.Parallel() + + region, err := getRandomRegion() + require.NoError(t, err) + + session, err := session.NewSession(&aws.Config{Region: aws.String(region)}) + require.NoError(t, err) + svc := ec2.New(session) + + natGateways := []*string{} + for i := 0; i < 3; i++ { + // We ignore errors in the delete call here, because it is intended to be a stop gap in case there is a bug in nuke. + ngwID := createNatGateway(t, svc, region) + defer deleteNatGateway(t, svc, ngwID, false) + natGateways = append(natGateways, ngwID) + } + + require.NoError( + t, + nukeAllNatGateways(session, natGateways), + ) + + // Make sure the NAT Gateway is deleted. + assertNatGatewaysDeleted(t, svc, natGateways) +} + +// Helper functions for driving the NAT gateway tests + +// createNatGateway will create a new NAT gateway in the default VPC +func createNatGateway(t *testing.T, svc *ec2.EC2, region string) *string { + defaultVpc := terraws.GetDefaultVpc(t, region) + subnet := defaultVpc.Subnets[0] + + resp, err := svc.CreateNatGateway(&ec2.CreateNatGatewayInput{ + SubnetId: aws.String(subnet.Id), + ConnectivityType: aws.String(ec2.ConnectivityTypePrivate), + }) + require.NoError(t, err) + if resp.NatGateway == nil { + t.Fatalf("Impossible error: AWS returned nil NAT gateway") + } + return resp.NatGateway.NatGatewayId +} + +// deleteNatGateway is a function to delete the given NAT gateway. +func deleteNatGateway(t *testing.T, svc *ec2.EC2, ngwID *string, checkErr bool) { + input := &ec2.DeleteNatGatewayInput{NatGatewayId: ngwID} + _, err := svc.DeleteNatGateway(input) + if checkErr { + require.NoError(t, err) + } +} + +func assertNatGatewaysDeleted(t *testing.T, svc *ec2.EC2, identifiers []*string) { + resp, err := svc.DescribeNatGateways(&ec2.DescribeNatGatewaysInput{NatGatewayIds: identifiers}) + require.NoError(t, err) + if len(resp.NatGateways) == 0 { + return + } + if len(resp.NatGateways) > len(identifiers) { + t.Fatalf("More than expected %d NAT gateway (found %d) for query", len(identifiers), len(resp.NatGateways)) + } + for _, ngw := range resp.NatGateways { + if ngw == nil { + continue + } + if aws.StringValue(ngw.State) != ec2.NatGatewayStateDeleted { + t.Fatalf("NAT Gateway not deleted by nuke operation") + } + } +} diff --git a/aws/nat_gateway_types.go b/aws/nat_gateway_types.go new file mode 100644 index 00000000..9f11bf87 --- /dev/null +++ b/aws/nat_gateway_types.go @@ -0,0 +1,38 @@ +package aws + +import ( + awsgo "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/gruntwork-io/go-commons/errors" +) + +// NatGateways - represents all AWS secrets manager secrets that should be deleted. +type NatGateways struct { + NatGatewayIDs []string +} + +// ResourceName - the simple name of the aws resource +func (ngw NatGateways) ResourceName() string { + return "nat-gateway" +} + +// ResourceIdentifiers - The instance ids of the ec2 instances +func (ngw NatGateways) ResourceIdentifiers() []string { + return ngw.NatGatewayIDs +} + +func (secret NatGateways) MaxBatchSize() int { + // Tentative batch size to ensure AWS doesn't throttle. Note that nat gateway does not support bulk delete, so + // we will be deleting this many in parallel using go routines. We conservatively pick 10 here, both to limit + // overloading the runtime and to avoid AWS throttling with many API calls. + return 10 +} + +// Nuke - nuke 'em all!!! +func (ngw NatGateways) Nuke(session *session.Session, identifiers []string) error { + if err := nukeAllNatGateways(session, awsgo.StringSlice(identifiers)); err != nil { + return errors.WithStackTrace(err) + } + + return nil +} From 21f3ef385c356a7b0e4cc4e7151e0d0ced939968 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Fri, 25 Jun 2021 16:03:59 -0500 Subject: [PATCH 4/8] Add config support for nuking NAT gateways --- .circleci/nuke_config.yml | 10 ++++++++ README.md | 52 ++++++++++----------------------------- aws/aws.go | 2 +- aws/nat_gateway.go | 23 ++++++++++++++--- aws/nat_gateway_test.go | 7 +++--- config/config.go | 1 + 6 files changed, 48 insertions(+), 47 deletions(-) diff --git a/.circleci/nuke_config.yml b/.circleci/nuke_config.yml index 9ce736b3..9abb23c0 100644 --- a/.circleci/nuke_config.yml +++ b/.circleci/nuke_config.yml @@ -24,3 +24,13 @@ SecretsManager: - "^RDSDBConfig[a-zA-Z0-9]{6}$" - "ECRDeployRunnerTestSSHKey-[a-zA-Z0-9]{6}$" - "ECRDeployRunnerTestGitPAT-[a-zA-Z0-9]{6}$" + +NatGateway: + # There is a bug in the cloud-nuke config where exclude does not work by itself, so we add a null include rule that + # includes everything. + include: + names_regex: + - ".*" + exclude: + names_regex: + - "^ecs-deploy-runner-v2-nat-gateway-0$" diff --git a/README.md b/README.md index c33fe70e..0f36a481 100644 --- a/README.md +++ b/README.md @@ -149,6 +149,9 @@ The following resources support the Config file: - Secrets Manager Secrets - Resource type: `secretsmanager` - Config key: `SecretsManager` +- NAT Gateways + - Resource type: `nat-gateway` + - Config key: `NATGateway` #### Example @@ -234,45 +237,16 @@ Be careful when nuking and append the `--dry-run` option if you're unsure. Even To find out what we options are supported in the config file today, consult this table. Resource types at the top level of the file that are supported are listed here. -| resource type | support | -|----------------|---------| -| s3 | partial | -| iam | partial | -| secretsmanager | partial | -| ec2 instance | none | -| iam role | none | -| ... (more to come) | none | - - -##### s3 resource type: -_Note: the fields without `_regex` suffixes refer to support for plain-text matching against those fields._ - -| field | include | exclude | -|-------------|---------|---------| -| names | none | none | -| names_regex | ✅ | ✅ | -| tags | none | none | -| tags_regex | none | none | - -##### iam resource type: -_Note: the fields without `_regex` suffixes refer to support for plain-text matching against those fields._ - -| field | include | exclude | -|-------------|---------|---------| -| names | none | none | -| names_regex | ✅ | ✅ | -| tags | none | none | -| tags_regex | none | none | - -##### secretsmanager resource type: -_Note: the fields without `_regex` suffixes refer to support for plain-text matching against those fields._ - -| field | include | exclude | -|-------------|---------|---------| -| names | none | none | -| names_regex | ✅ | ✅ | -| tags | none | none | -| tags_regex | none | none | +| resource type | names | names_regex | tags | tags_regex | +|--------------------|-------|-------------|------|------------| +| s3 | none | ✅ | none | none | +| iam | none | ✅ | none | none | +| secretsmanager | none | ✅ | none | none | +| nat-gateway | none | ✅ | none | none | +| ec2 instance | none | none | none | none | +| iam role | none | none | none | none | +| ... (more to come) | none | none | none | none | + ### Log level diff --git a/aws/aws.go b/aws/aws.go index 07c45926..c4f710be 100644 --- a/aws/aws.go +++ b/aws/aws.go @@ -339,7 +339,7 @@ func GetAllResources(targetRegions []string, excludeAfter time.Time, resourceTyp // NATGateway natGateways := NatGateways{} if IsNukeable(natGateways.ResourceName(), resourceTypes) { - ngwIDs, err := getAllNatGateways(session, excludeAfter) + ngwIDs, err := getAllNatGateways(session, excludeAfter, configObj) if err != nil { return nil, errors.WithStackTrace(err) } diff --git a/aws/nat_gateway.go b/aws/nat_gateway.go index 8d3d12c2..fecd3476 100644 --- a/aws/nat_gateway.go +++ b/aws/nat_gateway.go @@ -12,10 +12,11 @@ import ( "github.com/gruntwork-io/go-commons/retry" multierror "github.com/hashicorp/go-multierror" + "github.com/gruntwork-io/cloud-nuke/config" "github.com/gruntwork-io/cloud-nuke/logging" ) -func getAllNatGateways(session *session.Session, excludeAfter time.Time) ([]*string, error) { +func getAllNatGateways(session *session.Session, excludeAfter time.Time, configObj config.Config) ([]*string, error) { svc := ec2.New(session) allNatGateways := []*string{} @@ -24,7 +25,7 @@ func getAllNatGateways(session *session.Session, excludeAfter time.Time) ([]*str input, func(page *ec2.DescribeNatGatewaysOutput, lastPage bool) bool { for _, ngw := range page.NatGateways { - if shouldIncludeNatGateway(ngw, excludeAfter) { + if shouldIncludeNatGateway(ngw, excludeAfter, configObj) { allNatGateways = append(allNatGateways, ngw.NatGatewayId) } } @@ -34,7 +35,7 @@ func getAllNatGateways(session *session.Session, excludeAfter time.Time) ([]*str return allNatGateways, errors.WithStackTrace(err) } -func shouldIncludeNatGateway(ngw *ec2.NatGateway, excludeAfter time.Time) bool { +func shouldIncludeNatGateway(ngw *ec2.NatGateway, excludeAfter time.Time, configObj config.Config) bool { if ngw == nil { return false } @@ -42,7 +43,21 @@ func shouldIncludeNatGateway(ngw *ec2.NatGateway, excludeAfter time.Time) bool { if ngw.CreateTime != nil && excludeAfter.Before(*ngw.CreateTime) { return false } - return true + + return config.ShouldInclude( + getNatGatewayName(ngw), + configObj.NatGateway.IncludeRule.NamesRegExp, + configObj.NatGateway.ExcludeRule.NamesRegExp, + ) +} + +func getNatGatewayName(ngw *ec2.NatGateway) string { + for _, tag := range ngw.Tags { + if aws.StringValue(tag.Key) == "Name" { + return aws.StringValue(tag.Value) + } + } + return "" } func nukeAllNatGateways(session *session.Session, identifiers []*string) error { diff --git a/aws/nat_gateway_test.go b/aws/nat_gateway_test.go index 1695cbc6..c43bcb8e 100644 --- a/aws/nat_gateway_test.go +++ b/aws/nat_gateway_test.go @@ -7,6 +7,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/gruntwork-io/cloud-nuke/config" terraws "github.com/gruntwork-io/terratest/modules/aws" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -25,7 +26,7 @@ func TestListNatGateways(t *testing.T) { ngwID := createNatGateway(t, svc, region) defer deleteNatGateway(t, svc, ngwID, true) - natGatewayIDs, err := getAllNatGateways(session, time.Now()) + natGatewayIDs, err := getAllNatGateways(session, time.Now(), config.Config{}) require.NoError(t, err) assert.Contains(t, aws.StringValueSlice(natGatewayIDs), aws.StringValue(ngwID)) } @@ -45,13 +46,13 @@ func TestTimeFilterExclusionNewlyCreatedNatGateway(t *testing.T) { defer deleteNatGateway(t, svc, ngwID, true) // Assert NGW is picked up without filters - natGatewayIDsNewer, err := getAllNatGateways(session, time.Now()) + natGatewayIDsNewer, err := getAllNatGateways(session, time.Now(), config.Config{}) require.NoError(t, err) assert.Contains(t, aws.StringValueSlice(natGatewayIDsNewer), aws.StringValue(ngwID)) // Assert user doesn't appear when we look at users older than 1 Hour olderThan := time.Now().Add(-1 * time.Hour) - natGatewayIDsOlder, err := getAllNatGateways(session, olderThan) + natGatewayIDsOlder, err := getAllNatGateways(session, olderThan, config.Config{}) require.NoError(t, err) assert.NotContains(t, aws.StringValueSlice(natGatewayIDsOlder), aws.StringValue(ngwID)) } diff --git a/config/config.go b/config/config.go index 28ca1a3d..2a26c755 100644 --- a/config/config.go +++ b/config/config.go @@ -13,6 +13,7 @@ type Config struct { S3 ResourceType `yaml:"s3"` IAMUsers ResourceType `yaml:"IAMUsers"` SecretsManagerSecrets ResourceType `yaml:"SecretsManager"` + NatGateway ResourceType `yaml:"NatGateway"` } type ResourceType struct { From 0a89472eb1a54698c88a52c534ab2a5d0668d023 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Fri, 25 Jun 2021 16:18:55 -0500 Subject: [PATCH 5/8] Fix build error --- config/config_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/config/config_test.go b/config/config_test.go index cabf810a..bee2f57c 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -13,6 +13,7 @@ func emptyConfig() *Config { ResourceType{FilterRule{}, FilterRule{}}, ResourceType{FilterRule{}, FilterRule{}}, ResourceType{FilterRule{}, FilterRule{}}, + ResourceType{FilterRule{}, FilterRule{}}, } } From 33506cac1ba5379cefca75ec61b49a45d11524f8 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Mon, 28 Jun 2021 13:31:56 -0500 Subject: [PATCH 6/8] Hook up terratest log parser --- .circleci/config.yml | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index b684f672..84745ab4 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -8,8 +8,19 @@ jobs: steps: - checkout - run: - command: run-go-tests --timeout 45m + command: | + mkdir -p /tmp/logs + run-go-tests --timeout 45m | tee /tmp/logs/all.log no_output_timeout: 45m + - run: + name: parse test output + command: terratest_log_parser --testlog /tmp/logs/all.log --outputdir /tmp/logs + when: always + - store_artifacts: + path: /tmp/logs + - store_test_results: + path: /tmp/logs + build: <<: *defaults steps: From 996d7068a0b9da7e77c7d148e344fbd30ad38542 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Wed, 30 Jun 2021 09:52:15 -0500 Subject: [PATCH 7/8] Add comments requested from PR --- .circleci/nuke_config.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.circleci/nuke_config.yml b/.circleci/nuke_config.yml index 9abb23c0..21abba6c 100644 --- a/.circleci/nuke_config.yml +++ b/.circleci/nuke_config.yml @@ -28,9 +28,12 @@ SecretsManager: NatGateway: # There is a bug in the cloud-nuke config where exclude does not work by itself, so we add a null include rule that # includes everything. + # See https://github.com/gruntwork-io/cloud-nuke/issues/198 for more info. include: names_regex: - ".*" exclude: names_regex: + # We have an active ECS Deploy Runner running in the sandbox environment for sales demos, and this NAT gateway is + # critical for that. - "^ecs-deploy-runner-v2-nat-gateway-0$" From 039adb4788bb302f4447c87ce05f6bdb56b1d650 Mon Sep 17 00:00:00 2001 From: Yoriyasu Yano <430092+yorinasub17@users.noreply.github.com> Date: Wed, 30 Jun 2021 10:31:23 -0500 Subject: [PATCH 8/8] Add guard for failed batching --- aws/nat_gateway.go | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/aws/nat_gateway.go b/aws/nat_gateway.go index fecd3476..ef0e89a6 100644 --- a/aws/nat_gateway.go +++ b/aws/nat_gateway.go @@ -70,6 +70,15 @@ func nukeAllNatGateways(session *session.Session, identifiers []*string) error { return nil } + // NOTE: we don't need to do pagination here, because the pagination is handled by the caller to this function, + // based on NatGateways.MaxBatchSize, however we add a guard here to warn users when the batching fails and has a + // chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here + // because many APIs in AWS have a limit of 100 requests per second. + if len(identifiers) > 100 { + logging.Logger.Errorf("Nuking too many NAT gateways at once (100): halting to avoid hitting AWS API rate limiting") + return TooManyNatErr{} + } + // There is no bulk delete nat gateway API, so we delete the batch of nat gateways concurrently using go routines. logging.Logger.Infof("Deleting Nat Gateways in region %s", region) wg := new(sync.WaitGroup) @@ -124,7 +133,8 @@ func nukeAllNatGateways(session *session.Session, identifiers []*string) error { // querying for the statuses of all the NAT gateways, and checking if AWS knows about them (if not, the NAT gateway was // deleted and rolled off AWS DB) or if the status was updated to deleted. func areAllNatGatewaysDeleted(svc *ec2.EC2, identifiers []*string) (bool, error) { - // NOTE: we don't need to do pagination here, because the pagination is handled by the caller to this function. + // NOTE: we don't need to do pagination here, because the pagination is handled by the caller to this function, + // based on NatGateways.MaxBatchSize. resp, err := svc.DescribeNatGateways(&ec2.DescribeNatGatewaysInput{NatGatewayIds: identifiers}) if err != nil { return false, err @@ -154,3 +164,11 @@ func deleteNatGatewayAsync(wg *sync.WaitGroup, errChan chan error, svc *ec2.EC2, _, err := svc.DeleteNatGateway(input) errChan <- err } + +// Custom errors + +type TooManyNatErr struct{} + +func (err TooManyNatErr) Error() string { + return "Too many NAT Gateways requested at once." +}