From 5abb3c3a9b6024a5bb165ad93f2af50996de2816 Mon Sep 17 00:00:00 2001 From: Allen Lyons Date: Fri, 12 May 2023 11:02:33 -0400 Subject: [PATCH] removing version from docker-compose file (#80) * removing version from DC file * fixing docker-compose parsing issue * removing old test * tweaking build perms --- .github/workflows/build.yml | 4 +- cmd/task_describe.go | 4 +- dockercompose/main.go | 2 +- dockercompose/main_test.go | 37 +--- dockercompose/types.go | 19 +- ec2/mock/sdk/ec2iface.go | 333 ++++++++++++++++++++++++++++++++++++ 6 files changed, 358 insertions(+), 41 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 0b87d5c..bdd2c8e 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -25,7 +25,7 @@ jobs: - name: Push up a new pre-release if: ${{ contains(github.ref,'pre')}} env: - GITHUB_TOKEN: ${{ secrets.SECRET_GITHUB_TOKEN }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} run: make prerelease @@ -33,7 +33,7 @@ jobs: - name: Push up a new normal release if: ${{ !contains(github.ref,'pre')}} env: - GITHUB_TOKEN: ${{ secrets.SECRET_GITHUB_TOKEN }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} run: make release diff --git a/cmd/task_describe.go b/cmd/task_describe.go index 099bb39..147dc34 100644 --- a/cmd/task_describe.go +++ b/cmd/task_describe.go @@ -49,8 +49,8 @@ func describe(cmd *cobra.Command, args []string) { //ports for _, p := range container.PortMappings { service.Ports = append(service.Ports, dockercompose.Port{ - Published: *p.ContainerPort, - Target: *p.ContainerPort, + PublishedAsInt: *p.ContainerPort, + Target: *p.ContainerPort, }) } diff --git a/dockercompose/main.go b/dockercompose/main.go index 3a89716..b6c3fde 100644 --- a/dockercompose/main.go +++ b/dockercompose/main.go @@ -65,7 +65,7 @@ func (composeFile *ComposeFile) Read() error { return fmt.Errorf("unmarshalling docker compose yaml: %w", err) } if len(compose.Services) == 0 { - return errors.New("unable to parse compose file") + return errors.New("unable to parse compose file, no services found") } composeFile.Data = compose return nil diff --git a/dockercompose/main_test.go b/dockercompose/main_test.go index 97e1759..76d01cb 100644 --- a/dockercompose/main_test.go +++ b/dockercompose/main_test.go @@ -41,7 +41,7 @@ func TestComposeV2(t *testing.T) { if svc.Image != image { t.Error("expecting image") } - if svc.Ports[0].Published != publishedPort { + if svc.Ports[0].PublishedAsInt != publishedPort { t.Error("expecting published port") } if svc.Ports[0].Target != targetPort { @@ -63,7 +63,7 @@ func TestComposeV24(t *testing.T) { if svc.Image != image { t.Error("expecting image") } - if svc.Ports[0].Published != publishedPort { + if svc.Ports[0].PublishedAsInt != publishedPort { t.Error("expecting published port") } if svc.Ports[0].Target != targetPort { @@ -89,7 +89,7 @@ func TestComposeV32Short(t *testing.T) { if svc.Image != image { t.Error("expecting image") } - if svc.Ports[0].Published != publishedPort { + if svc.Ports[0].PublishedAsInt != publishedPort { t.Error("expecting published port") } if svc.Ports[0].Target != targetPort { @@ -111,7 +111,7 @@ func TestComposeV32Long(t *testing.T) { if svc.Image != image { t.Error("expecting image") } - if svc.Ports[0].Published != publishedPort { + if svc.Ports[0].PublishedAsInt != publishedPort { t.Error("expecting published port") } if svc.Ports[0].Target != targetPort { @@ -133,33 +133,8 @@ func TestComposeV37(t *testing.T) { if svc.Image != image { t.Error("expecting image") } - if svc.Ports[0].Published != publishedPort { - t.Error("expecting published port") - } - if svc.Ports[0].Target != targetPort { - t.Error("expecting published port") - } - if svc.Labels[labelKey] != labelValue { - t.Error("expecting label") - } - if svc.Secrets[secretKey] != secretValue { - t.Error("expecting secret") - } -} - -// 3.8 -func TestComposeV38(t *testing.T) { - f, e := doTest(t, "v3.8.yml") - if e != nil { - t.Error(e) - return - } - svc := f.Data.Services["web"] - if svc.Image != image { - t.Error("expecting image") - } - if svc.Ports[0].Published != publishedPort { - t.Error("expecting published port") + if svc.Ports[0].PublishedAsInt != publishedPort { + t.Errorf("expecting published port to be %d, was %d", publishedPort, svc.Ports[0].PublishedAsInt) } if svc.Ports[0].Target != targetPort { t.Error("expecting published port") diff --git a/dockercompose/types.go b/dockercompose/types.go index e48fc49..fbc59a6 100644 --- a/dockercompose/types.go +++ b/dockercompose/types.go @@ -23,8 +23,9 @@ type Service struct { // Port represents a port type Port struct { - Published int64 `yaml:"published"` - Target int64 `yaml:"target"` + PublishedAsString string `yaml:"published"` + PublishedAsInt int64 + Target int64 `yaml:"target"` } // used to parse the short syntax @@ -73,8 +74,9 @@ func UnmarshalComposeYAML(yamlBytes []byte) (DockerCompose, error) { return result, err } ports = append(ports, Port{ - Published: published, - Target: target, + PublishedAsInt: published, + PublishedAsString: portString[0], + Target: target, }) } @@ -87,12 +89,19 @@ func UnmarshalComposeYAML(yamlBytes []byte) (DockerCompose, error) { } } } else { //error unmarshaling short syntax - //try long syntax err := yaml.Unmarshal(yamlBytes, &result) if err != nil { return result, nil } + + for _, svc := range result.Services { + //convert ports + for i, _ := range svc.Ports { + svc.Ports[i].PublishedAsInt, _ = strconv.ParseInt(svc.Ports[i].PublishedAsString, 10, 64) + } + } + } return result, nil diff --git a/ec2/mock/sdk/ec2iface.go b/ec2/mock/sdk/ec2iface.go index 7089746..b9e24f7 100644 --- a/ec2/mock/sdk/ec2iface.go +++ b/ec2/mock/sdk/ec2iface.go @@ -736,6 +736,56 @@ func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesWithContext(arg0, arg1 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesWithContext), varargs...) } +// AssignPrivateNatGatewayAddress mocks base method. +func (m *MockEC2API) AssignPrivateNatGatewayAddress(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*ec2.AssignPrivateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddress", arg0) + ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignPrivateNatGatewayAddress indicates an expected call of AssignPrivateNatGatewayAddress. +func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddress), arg0) +} + +// AssignPrivateNatGatewayAddressRequest mocks base method. +func (m *MockEC2API) AssignPrivateNatGatewayAddressRequest(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*request.Request, *ec2.AssignPrivateNatGatewayAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssignPrivateNatGatewayAddressOutput) + return ret0, ret1 +} + +// AssignPrivateNatGatewayAddressRequest indicates an expected call of AssignPrivateNatGatewayAddressRequest. +func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddressRequest), arg0) +} + +// AssignPrivateNatGatewayAddressWithContext mocks base method. +func (m *MockEC2API) AssignPrivateNatGatewayAddressWithContext(arg0 aws.Context, arg1 *ec2.AssignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssignPrivateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignPrivateNatGatewayAddressWithContext indicates an expected call of AssignPrivateNatGatewayAddressWithContext. +func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddressWithContext(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, "AssignPrivateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddressWithContext), varargs...) +} + // AssociateAddress mocks base method. func (m *MockEC2API) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) { m.ctrl.T.Helper() @@ -1086,6 +1136,56 @@ func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscoveryWithContext(arg0 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscoveryWithContext), varargs...) } +// AssociateNatGatewayAddress mocks base method. +func (m *MockEC2API) AssociateNatGatewayAddress(arg0 *ec2.AssociateNatGatewayAddressInput) (*ec2.AssociateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateNatGatewayAddress", arg0) + ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateNatGatewayAddress indicates an expected call of AssociateNatGatewayAddress. +func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddress), arg0) +} + +// AssociateNatGatewayAddressRequest mocks base method. +func (m *MockEC2API) AssociateNatGatewayAddressRequest(arg0 *ec2.AssociateNatGatewayAddressInput) (*request.Request, *ec2.AssociateNatGatewayAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateNatGatewayAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateNatGatewayAddressOutput) + return ret0, ret1 +} + +// AssociateNatGatewayAddressRequest indicates an expected call of AssociateNatGatewayAddressRequest. +func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddressRequest), arg0) +} + +// AssociateNatGatewayAddressWithContext mocks base method. +func (m *MockEC2API) AssociateNatGatewayAddressWithContext(arg0 aws.Context, arg1 *ec2.AssociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssociateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateNatGatewayAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateNatGatewayAddressWithContext indicates an expected call of AssociateNatGatewayAddressWithContext. +func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddressWithContext(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, "AssociateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddressWithContext), varargs...) +} + // AssociateRouteTable mocks base method. func (m *MockEC2API) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) { m.ctrl.T.Helper() @@ -22716,6 +22816,56 @@ func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscoveryWithContext(a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscoveryWithContext), varargs...) } +// DisassociateNatGatewayAddress mocks base method. +func (m *MockEC2API) DisassociateNatGatewayAddress(arg0 *ec2.DisassociateNatGatewayAddressInput) (*ec2.DisassociateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateNatGatewayAddress", arg0) + ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateNatGatewayAddress indicates an expected call of DisassociateNatGatewayAddress. +func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddress), arg0) +} + +// DisassociateNatGatewayAddressRequest mocks base method. +func (m *MockEC2API) DisassociateNatGatewayAddressRequest(arg0 *ec2.DisassociateNatGatewayAddressInput) (*request.Request, *ec2.DisassociateNatGatewayAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateNatGatewayAddressOutput) + return ret0, ret1 +} + +// DisassociateNatGatewayAddressRequest indicates an expected call of DisassociateNatGatewayAddressRequest. +func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddressRequest), arg0) +} + +// DisassociateNatGatewayAddressWithContext mocks base method. +func (m *MockEC2API) DisassociateNatGatewayAddressWithContext(arg0 aws.Context, arg1 *ec2.DisassociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.DisassociateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateNatGatewayAddressWithContext indicates an expected call of DisassociateNatGatewayAddressWithContext. +func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddressWithContext(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, "DisassociateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddressWithContext), varargs...) +} + // DisassociateRouteTable mocks base method. func (m *MockEC2API) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) { m.ctrl.T.Helper() @@ -26726,6 +26876,56 @@ func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesWithContext(arg0, a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesWithContext), varargs...) } +// GetVpnTunnelReplacementStatus mocks base method. +func (m *MockEC2API) GetVpnTunnelReplacementStatus(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*ec2.GetVpnTunnelReplacementStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatus", arg0) + ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetVpnTunnelReplacementStatus indicates an expected call of GetVpnTunnelReplacementStatus. +func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatus", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatus), arg0) +} + +// GetVpnTunnelReplacementStatusRequest mocks base method. +func (m *MockEC2API) GetVpnTunnelReplacementStatusRequest(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*request.Request, *ec2.GetVpnTunnelReplacementStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetVpnTunnelReplacementStatusOutput) + return ret0, ret1 +} + +// GetVpnTunnelReplacementStatusRequest indicates an expected call of GetVpnTunnelReplacementStatusRequest. +func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatusRequest), arg0) +} + +// GetVpnTunnelReplacementStatusWithContext mocks base method. +func (m *MockEC2API) GetVpnTunnelReplacementStatusWithContext(arg0 aws.Context, arg1 *ec2.GetVpnTunnelReplacementStatusInput, arg2 ...request.Option) (*ec2.GetVpnTunnelReplacementStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetVpnTunnelReplacementStatusWithContext indicates an expected call of GetVpnTunnelReplacementStatusWithContext. +func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatusWithContext(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, "GetVpnTunnelReplacementStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatusWithContext), varargs...) +} + // ImportClientVpnClientCertificateRevocationList mocks base method. func (m *MockEC2API) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { m.ctrl.T.Helper() @@ -31792,6 +31992,56 @@ func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteWithContext(arg0, ar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteWithContext), varargs...) } +// ReplaceVpnTunnel mocks base method. +func (m *MockEC2API) ReplaceVpnTunnel(arg0 *ec2.ReplaceVpnTunnelInput) (*ec2.ReplaceVpnTunnelOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceVpnTunnel", arg0) + ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceVpnTunnel indicates an expected call of ReplaceVpnTunnel. +func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnel(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnel", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnel), arg0) +} + +// ReplaceVpnTunnelRequest mocks base method. +func (m *MockEC2API) ReplaceVpnTunnelRequest(arg0 *ec2.ReplaceVpnTunnelInput) (*request.Request, *ec2.ReplaceVpnTunnelOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceVpnTunnelRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceVpnTunnelOutput) + return ret0, ret1 +} + +// ReplaceVpnTunnelRequest indicates an expected call of ReplaceVpnTunnelRequest. +func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnelRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnelRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnelRequest), arg0) +} + +// ReplaceVpnTunnelWithContext mocks base method. +func (m *MockEC2API) ReplaceVpnTunnelWithContext(arg0 aws.Context, arg1 *ec2.ReplaceVpnTunnelInput, arg2 ...request.Option) (*ec2.ReplaceVpnTunnelOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceVpnTunnelWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceVpnTunnelWithContext indicates an expected call of ReplaceVpnTunnelWithContext. +func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnelWithContext(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, "ReplaceVpnTunnelWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnelWithContext), varargs...) +} + // ReportInstanceStatus mocks base method. func (m *MockEC2API) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) { m.ctrl.T.Helper() @@ -33508,6 +33758,56 @@ func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesWithContext(arg0, ar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesWithContext), varargs...) } +// UnassignPrivateNatGatewayAddress mocks base method. +func (m *MockEC2API) UnassignPrivateNatGatewayAddress(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddress", arg0) + ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignPrivateNatGatewayAddress indicates an expected call of UnassignPrivateNatGatewayAddress. +func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddress), arg0) +} + +// UnassignPrivateNatGatewayAddressRequest mocks base method. +func (m *MockEC2API) UnassignPrivateNatGatewayAddressRequest(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*request.Request, *ec2.UnassignPrivateNatGatewayAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UnassignPrivateNatGatewayAddressOutput) + return ret0, ret1 +} + +// UnassignPrivateNatGatewayAddressRequest indicates an expected call of UnassignPrivateNatGatewayAddressRequest. +func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddressRequest), arg0) +} + +// UnassignPrivateNatGatewayAddressWithContext mocks base method. +func (m *MockEC2API) UnassignPrivateNatGatewayAddressWithContext(arg0 aws.Context, arg1 *ec2.UnassignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignPrivateNatGatewayAddressWithContext indicates an expected call of UnassignPrivateNatGatewayAddressWithContext. +func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddressWithContext(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, "UnassignPrivateNatGatewayAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddressWithContext), varargs...) +} + // UnmonitorInstances mocks base method. func (m *MockEC2API) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) { m.ctrl.T.Helper() @@ -34384,6 +34684,39 @@ func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompletedWithContext(arg0, ar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompletedWithContext), varargs...) } +// WaitUntilSnapshotImported mocks base method. +func (m *MockEC2API) WaitUntilSnapshotImported(arg0 *ec2.DescribeImportSnapshotTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSnapshotImported", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSnapshotImported indicates an expected call of WaitUntilSnapshotImported. +func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotImported(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotImported", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotImported), arg0) +} + +// WaitUntilSnapshotImportedWithContext mocks base method. +func (m *MockEC2API) WaitUntilSnapshotImportedWithContext(arg0 aws.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSnapshotImportedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSnapshotImportedWithContext indicates an expected call of WaitUntilSnapshotImportedWithContext. +func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotImportedWithContext(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, "WaitUntilSnapshotImportedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotImportedWithContext), varargs...) +} + // WaitUntilSpotInstanceRequestFulfilled mocks base method. func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error { m.ctrl.T.Helper()